Some changes and flie splitting

file_explorer_and_upload.py

@@ -0,0 +1,115 @@
+import os
+import gradio as gr
+import shutil
+from PIL import Image
+import tempfile
+import json
+import zipfile
+
+# Set the directory where files will be saved
+SAVE_DIR = os.path.abspath("saved_media") #make sure its the as media_folder Above
+
+# Ensure the save directory exists
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+# Define supported file extensions
+SUPPORTED_EXTENSIONS = {
+    "image": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"],
+    "audio": [".mp3", ".wav", ".ogg"],
+    "video": [".mp4", ".avi", ".mov", ".webm"]
+}
+
+def save_file(file):
+    if file is None:
+        return "No file uploaded.", gr.update()
+
+    try:
+        # Get the original filename and extension
+        original_filename = os.path.basename(file.name)
+        _, extension = os.path.splitext(original_filename)
+
+        # Check if the file extension is supported
+        if not any(extension.lower() in exts for exts in SUPPORTED_EXTENSIONS.values()):
+            return f"Unsupported file type: {extension}", gr.update()
+
+        # Create a unique filename to avoid overwriting
+        base_name = os.path.splitext(original_filename)[0]
+        counter = 1
+        new_filename = f"{base_name}{extension}"
+        while os.path.exists(os.path.join(SAVE_DIR, new_filename)):
+            new_filename = f"{base_name}_{counter}{extension}"
+            counter += 1
+
+        # Copy the file from the temporary location to our save directory
+        dest_path = os.path.join(SAVE_DIR, new_filename)
+        shutil.copy2(file.name, dest_path)
+
+        # Return success message and updated FileExplorer
+        return f"File saved as {SAVE_DIR}/{new_filename}", gr.update(value=SAVE_DIR), gr.update(value=None)
+    except Exception as e:
+        return f"Error saving file: {str(e)}", gr.update(value=SAVE_DIR), gr.update()
+
+def view_file(file_path):
+    if not file_path:
+        return None, None, None, "No file selected."
+
+    try:
+        full_path = os.path.join(SAVE_DIR, file_path)
+        _, extension = os.path.splitext(full_path)
+        extension = extension.lower()
+
+        if extension in SUPPORTED_EXTENSIONS["image"]:
+            return Image.open(full_path), None, None, None
+        elif extension in SUPPORTED_EXTENSIONS["audio"]:
+            return None, full_path, None, None
+        elif extension in SUPPORTED_EXTENSIONS["video"]:
+            return None, None, full_path, None
+        else:
+            return None, None, None, f"Unsupported file type: {extension}"
+    except Exception as e:
+        return None, None, None, f"Error viewing file: {str(e)}"
+
+def refresh_file_explorer():
+    return gr.update()
+
+def import_config_with_media(zip_path):
+    global SAVE_DIR
+    target_folder = SAVE_DIR
+    """
+    Import the config JSON and media files from a zip file.
+    Extract only the media files that don't already exist in the target folder.
+    
+    :param zip_path: Path to the zip file containing the config and media files
+    :param target_folder: Path to the folder where media files should be extracted
+    :return: Tuple containing the loaded config (as a dictionary) and a list of newly extracted files
+    """
+    config = None
+    extracted_files = []
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Extract all files to a temporary directory
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir)
+        
+        # Load the config
+        config_path = os.path.join(temp_dir, 'config.json')
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+        else:
+            raise FileNotFoundError("config.json not found in the zip file")
+        
+        # Create the target folder if it doesn't exist
+        os.makedirs(target_folder, exist_ok=True)
+        
+        # Copy media files that don't already exist in the target folder
+        for root, _, files in os.walk(temp_dir):
+            for file in files:
+                if file != 'config.json':
+                    src_path = os.path.join(root, file)
+                    dst_path = os.path.join(target_folder, file)
+                    if not os.path.exists(dst_path):
+                        shutil.copy2(src_path, dst_path)
+                        extracted_files.append(file)
+    
+    return config, extracted_files

jsconfig_idea_support.py

@@ -0,0 +1,22 @@
+#importing default_config from relatively_constant_variables (app.py)
+
+# Helper functions to dynamically add items
+def add_inventory_item(inventory_items, type, name, description):
+    new_item = {"type": type, "name": name, "description": description}
+    inventory_items.append(new_item)
+    return inventory_items
+
+def add_skill(skills_items, branch, name, learned):
+    new_skill = {"branch": branch, "name": name, "learned": learned == 'True'}
+    skills_items.append(new_skill)
+    return skills_items
+
+def add_objective(objectives_items, id, name, complete):
+    new_objective = {"id": id, "name": name, "complete": complete == 'True'}
+    objectives_items.append(new_objective)
+    return objectives_items
+
+def add_target(targets_items, name, x, y, collisionType, collisiontext):
+    new_target = {"name": name, "x": int(x), "y": int(y), "collisionType": collisionType, "collisiontext": collisiontext}
+    targets_items.append(new_target)
+    return targets_items

leveraging_machine_learning.py

@@ -0,0 +1,338 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+import gc
+import sys
+from diffusers import FluxPipeline
+import time
+from sentence_transformers import SentenceTransformer
+import psutil
+import json
+import spaces
+from threading import Thread
+#-----------------
+from relatively_constant_variables import knowledge_base
+
+# Initialize the zero tensor on CUDA
+zero = torch.Tensor([0]).cuda()
+print(zero.device)  # This will print 'cpu' outside the @spaces.GPU decorated function
+
+modelnames = ["stvlynn/Gemma-2-2b-Chinese-it", "nbeerbower/mistral-nemo-wissenschaft-12B", "princeton-nlp/gemma-2-9b-it-SimPO", "cognitivecomputations/dolphin-2.9.3-mistral-7B-32k", "01-ai/Yi-Coder-9B-Chat", "ArliAI/Llama-3.1-8B-ArliAI-RPMax-v1.1", "ArliAI/Phi-3.5-mini-3.8B-ArliAI-RPMax-v1.1", 
+              "Qwen/Qwen2.5-7B-Instruct", "Qwen/Qwen2-0.5B-Instruct", "Qwen/Qwen2-1.5B-Instruct", "Qwen/Qwen2-7B-Instruct", "Qwen/Qwen1.5-MoE-A2.7B-Chat", "HuggingFaceTB/SmolLM-135M-Instruct", "microsoft/Phi-3-mini-4k-instruct", "Groq/Llama-3-Groq-8B-Tool-Use", "hugging-quants/Meta-Llama-3.1-8B-Instruct-BNB-NF4", 
+              "SpectraSuite/TriLM_3.9B_Unpacked", "h2oai/h2o-danube3-500m-chat", "OuteAI/Lite-Mistral-150M-v2-Instruct", "Zyphra/Zamba2-1.2B", "anthracite-org/magnum-v2-4b", ]
+
+imagemodelnames = ["black-forest-labs/FLUX.1-schnell"]
+
+current_model_index = 0
+current_image_model_index = 0
+modelname = modelnames[current_model_index]
+imagemodelname = imagemodelnames[current_image_model_index]
+lastmodelnameinloadfunction = None
+lastimagemodelnameinloadfunction = None
+
+# Load the embedding model
+embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+
+# Initialize model and tokenizer as global variables
+model = None
+tokenizer = None
+flux_pipe = None
+
+# Dictionary to store loaded models
+loaded_models = {}
+
+def get_size_str(bytes):
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if bytes < 1024:
+            return f"{bytes:.2f} {unit}"
+        bytes /= 1024
+
+def load_model(model_name):
+    global model, tokenizer, lastmodelnameinloadfunction, loaded_models
+
+    print(f"Loading model and tokenizer: {model_name}")
+    
+    # Record initial GPU memory usage
+    initial_memory = torch.cuda.memory_allocated()
+
+    # Clear old model and tokenizer if they exist
+    if 'model' in globals() and model is not None:
+        model = None
+    if 'tokenizer' in globals() and tokenizer is not None:
+        tokenizer = None
+    
+    torch.cuda.empty_cache()
+    gc.collect()
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        torch_dtype="auto",
+        device_map="auto"
+    )
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model_size = sum(p.numel() * p.element_size() for p in model.parameters())
+    tokenizer_size = sum(sys.getsizeof(v) for v in tokenizer.__dict__.values())
+    loaded_models[model_name] = (model, tokenizer)
+
+    # Calculate memory usage
+    final_memory = torch.cuda.memory_allocated()
+    memory_used = final_memory - initial_memory
+
+    loaded_models[model_name] = [str(time.time()), memory_used]
+
+    lastmodelnameinloadfunction = (model_name, model_size, tokenizer_size)
+    print(f"Model and tokenizer {model_name} loaded successfully")
+    print(f"Model size: {get_size_str(model_size)}")
+    print(f"Tokenizer size: {get_size_str(tokenizer_size)}")
+    print(f"GPU memory used: {get_size_str(memory_used)}")
+
+    return (f"Model and tokenizer {model_name} loaded successfully. "
+            f"Model size: {get_size_str(model_size)}, "
+            f"Tokenizer size: {get_size_str(tokenizer_size)}, "
+            f"GPU memory used: {get_size_str(memory_used)}")
+
+def load_image_model(imagemodelname):
+    global flux_pipe, lastimagemodelnameinloadfunction, loaded_models
+
+    print(f"Loading image model: {imagemodelname}")
+    
+    # Record initial GPU memory usage
+    initial_memory = torch.cuda.memory_allocated()
+
+    if 'flux_pipe' in globals() and flux_pipe is not None:
+        flux_pipe = None
+    
+    torch.cuda.empty_cache()
+    gc.collect()
+
+    flux_pipe = FluxPipeline.from_pretrained(imagemodelname, torch_dtype=torch.bfloat16)
+    flux_pipe.enable_model_cpu_offload()
+    model_size = sum(p.numel() * p.element_size() for p in flux_pipe.transformer.parameters())
+    #tokenizer_size = 0  # FLUX doesn't use a separate tokenizer
+    loaded_models[imagemodelname] = flux_pipe
+
+    # Calculate memory usage
+    final_memory = torch.cuda.memory_allocated()
+    memory_used = final_memory - initial_memory
+
+    loaded_models[imagemodelname] = [str(time.time()), memory_used]
+
+    lastimagemodelnameinloadfunction = (imagemodelname, model_size) #, tokenizer_size)
+    print(f"Model and tokenizer {imagemodelname} loaded successfully")
+    print(f"Model size: {get_size_str(model_size)}")
+    #print(f"Tokenizer size: {get_size_str(tokenizer_size)}")
+    print(f"GPU memory used: {get_size_str(memory_used)}")
+
+    return (f"Model and tokenizer {imagemodelname} loaded successfully. "
+            f"Model size: {get_size_str(model_size)}, "
+            #f"Tokenizer size: {get_size_str(tokenizer_size)}, "
+            f"GPU memory used: {get_size_str(memory_used)}")
+
+
+def clear_all_models():
+    global model, tokenizer, flux_pipe, loaded_models
+    for model_name, model_obj in loaded_models.items():
+        if isinstance(model_obj, tuple):
+            model_obj[0].to('cpu')
+            del model_obj[0]
+            del model_obj[1]
+        else:
+            model_obj.to('cpu')
+            del model_obj
+    model = None
+    tokenizer = None
+    flux_pipe = None
+    loaded_models.clear()
+    torch.cuda.empty_cache()
+    gc.collect()
+    return "All models cleared from memory."
+
+def load_model_list(model_list):
+    messages = []
+    for model_name in model_list:
+        message = load_model(model_name)
+        messages.append(message)
+    return "\n".join(messages)
+
+def loaded_model_list():
+    global loaded_models
+    return loaded_models
+
+
+# Initial model load
+load_model(modelname)
+load_image_model(imagemodelname)
+
+# Create embeddings for the knowledge base
+knowledge_base_embeddings = embedding_model.encode([doc["content"] for doc in knowledge_base])
+
+def retrieve(query, k=2):
+    query_embedding = embedding_model.encode([query])
+    similarities = torch.nn.functional.cosine_similarity(torch.tensor(query_embedding), torch.tensor(knowledge_base_embeddings))
+    top_k_indices = similarities.argsort(descending=True)[:k]
+    return [(knowledge_base[i]["content"], knowledge_base[i]["id"]) for i in top_k_indices]
+
+def get_ram_usage():
+    ram = psutil.virtual_memory()
+    return f"RAM Usage: {ram.percent:.2f}%, Available: {ram.available / (1024 ** 3):.2f}GB, Total: {ram.total / (1024 ** 3):.2f}GB"
+
+# Global dictionary to store outputs
+output_dict = {}
+
+def empty_output_dict():
+    global output_dict
+    output_dict = {}
+    print("Output dictionary has been emptied.")
+
+def get_model_details(model):
+    return {
+        "name": model.config.name_or_path,
+        "architecture": model.config.architectures[0] if model.config.architectures else "Unknown",
+        "num_parameters": sum(p.numel() for p in model.parameters()),
+    }
+
+def get_tokenizer_details(tokenizer):
+    return {
+        "name": tokenizer.__class__.__name__,
+        "vocab_size": tokenizer.vocab_size,
+        "model_max_length": tokenizer.model_max_length,
+    }
+
+@spaces.GPU
+def generate_response(prompt, use_rag, stream=False):
+    global output_dict, model, tokenizer
+    
+    print(zero.device)  # This will print 'cuda:0' inside the @spaces.GPU decorated function
+    torch.cuda.empty_cache()
+    print(dir(model))
+
+    if use_rag:
+        retrieved_docs = retrieve(prompt)
+        context = " ".join([doc for doc, _ in retrieved_docs])
+        doc_ids = [doc_id for _, doc_id in retrieved_docs]
+        full_prompt = f"Context: {context}\nQuestion: {prompt}\nAnswer:"
+    else:
+        full_prompt = prompt
+        doc_ids = None
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": full_prompt}
+    ]
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
+    model_inputs = tokenizer([text], return_tensors="pt").to(zero.device)
+    start_time = time.time()
+    total_tokens = 0
+    
+    print(output_dict)
+    output_key = f"output_{len(output_dict) + 1}"
+    print(output_key)
+    output_dict[output_key] = {
+        "input_prompt": prompt,
+        "full_prompt": full_prompt,
+        "use_rag": use_rag,
+        "generated_text": "",
+        "tokens_per_second": 0,
+        "ram_usage": "",
+        "doc_ids": doc_ids if doc_ids else "N/A",
+        "model_details": get_model_details(model),
+        "tokenizer_details": get_tokenizer_details(tokenizer),
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(start_time))
+    }
+    print(output_dict)
+
+    if stream:
+        streamer = TextIteratorStreamer(tokenizer, skip_special_tokens=True)
+        generation_kwargs = dict(
+            model_inputs,
+            streamer=streamer,
+            max_new_tokens=512,
+            temperature=0.7,
+        )
+        thread = Thread(target=model.generate, kwargs=generation_kwargs)
+        thread.start()
+        for new_text in streamer:
+            output_dict[output_key]["generated_text"] += new_text
+            total_tokens += 1
+            current_time = time.time()
+            tokens_per_second = total_tokens / (current_time - start_time)
+            ram_usage = get_ram_usage()
+            output_dict[output_key]["tokens_per_second"] = f"{tokens_per_second:.2f}"
+            output_dict[output_key]["ram_usage"] = ram_usage
+            yield (output_dict[output_key]["generated_text"], 
+                output_dict[output_key]["tokens_per_second"], 
+                output_dict[output_key]["ram_usage"], 
+                output_dict[output_key]["doc_ids"])
+    else:
+        generated_ids = model.generate(
+            model_inputs.input_ids,
+            max_new_tokens=512
+        )
+        generated_ids = [
+            output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+        ]
+        response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        total_tokens = len(generated_ids[0])
+        end_time = time.time()
+        tokens_per_second = total_tokens / (end_time - start_time)
+        ram_usage = get_ram_usage()
+        
+        output_dict[output_key]["generated_text"] = response
+        output_dict[output_key]["tokens_per_second"] = f"{tokens_per_second:.2f}"
+        output_dict[output_key]["ram_usage"] = ram_usage
+        print(output_dict)
+
+        yield (output_dict[output_key]["generated_text"], 
+            output_dict[output_key]["tokens_per_second"], 
+            output_dict[output_key]["ram_usage"], 
+            output_dict[output_key]["doc_ids"])
+            
+@spaces.GPU
+def generate_image(prompt):
+    global output_dict, flux_pipe
+    
+    print(dir(flux_pipe))
+
+    # Generate image using FLUX
+    image = flux_pipe(
+        prompt,
+        guidance_scale=0.0,
+        num_inference_steps=4,
+        max_sequence_length=256,
+        generator=torch.Generator("cpu").manual_seed(0)
+    ).images[0]
+    image_path = f"flux_output_{time.time()}.png"
+    print(image_path)
+    image.save(image_path)
+    ram_usage = get_ram_usage()
+    return image_path, ram_usage, image_path
+
+def get_output_details(output_key):
+    if output_key in output_dict:
+        return output_dict[output_key]
+    else:
+        return f"No output found for key: {output_key}"
+
+# Update the switch_model function to return the load_model message
+def switch_model(choice):
+    global modelname
+    modelname = choice
+    load_message = load_model(modelname)
+    return load_message, f"Current model: {modelname}"
+
+# Update the model_change_handler function
+def model_change_handler(choice):
+    message, current_model = switch_model(choice)
+    return message, current_model, message  # Use the same message for both outputs
+
+def format_output_dict():
+    global output_dict
+    formatted_output = ""
+    for key, value in output_dict.items():
+        formatted_output += f"Key: {key}\n"
+        formatted_output += json.dumps(value, indent=2)
+        formatted_output += "\n\n"
+    print(formatted_output)
+    return formatted_output

my_text_game_engine_attempt.py

@@ -0,0 +1,285 @@
+import gradio as gr
+import json
+import os
+import tempfile
+import shutil
+import zipfile
+from relatively_constant_variables import finished_product_demo, all_states
+
+class Player:
+    def __init__(self):
+        self.inventory = []
+        self.money = 20
+        self.knowledge = {}
+
+    def add_item(self, item):
+        self.inventory.append(item)
+
+    def has_item(self, item):
+        return item in self.inventory
+
+    def update_knowledge(self, topic):
+        self.knowledge[topic] = True
+
+class GameSession:
+    def __init__(self, starting_location='village', starting_state='start'):
+        self.player = Player()
+        self.current_location = starting_location
+        self.current_state = starting_state
+        self.game_log = []
+
+    def make_choice(self, choice_index):
+        state = all_states[self.current_location][self.current_state]
+        if 0 <= choice_index < len(state['choices']):
+            choice = state['choices'][choice_index]
+            next_state = state['transitions'][choice]
+
+            self.game_log.append(f"You chose: {choice}")
+            self.game_log.append(state['description'])
+
+            if 'consequences' in state and choice in state['consequences']:
+              if state['consequences'][choice]:
+                  state['consequences'][choice](self.player)
+              else:
+                  # Handle empty consequence, e.g., log a message or provide a default action
+                  print(f"No consequence for choice: {choice}")
+                  # You can add any default action here if needed
+
+            if '_' in next_state:
+                self.current_location, self.current_state = next_state.split('_')
+            else:
+                self.current_state = next_state
+
+            return self.get_current_state_info()
+        else:
+            return "Invalid choice. Please try again."
+
+    def get_current_state_info(self):
+        state = all_states[self.current_location][self.current_state]
+        choices = [f"{idx + 1}. {choice}" for idx, choice in enumerate(state['choices'])]
+        return state['description'], choices, "\n".join(self.game_log)
+    
+    def get_current_state_media(self):
+        media = all_states[self.current_location][self.current_state]['media']
+        return media
+
+def start_game(starting_location='village', starting_state='start', new_states=all_states):
+    global all_states
+    game_session = GameSession(starting_location, starting_state)
+    description, choices, game_log = game_session.get_current_state_info()
+    all_states = new_states
+    return description, choices, game_log, game_session
+
+def make_choice(choice, game_session, with_media=False): #Calls the nested make choice function in the game session class
+    if not choice:
+        description, choices, game_log = game_session.get_current_state_info()
+        return description, choices, "Please select a choice before proceeding.", game_session
+
+    choice_index = int(choice.split('.')[0]) - 1 
+    result = game_session.make_choice(choice_index)
+
+    if with_media:
+        media = game_session.get_current_state_media()
+        return result[0], gr.update(choices=result[1]), result[2], game_session, media
+    else:
+        return result[0], gr.update(choices=result[1]), result[2], game_session
+
+def validate_transitions(all_states):
+    errors = []
+    for location, states in all_states.items():
+        for state_key, state in states.items():
+            for transition_key, transition_state in state['transitions'].items():
+                # Check if the transition is to another location
+                if transition_state in all_states:
+                    trans_location, trans_state = transition_state, 'start'  # Assuming 'start' state for new locations
+                elif '_' in transition_state:
+                    trans_location, trans_state = transition_state.split('_')
+                else:
+                    trans_location, trans_state = location, transition_state
+
+                # Validate the transition state
+                if trans_location not in all_states or trans_state not in all_states[trans_location]:
+                    errors.append(f"Invalid transition from {location}.{state_key} to {trans_location}.{trans_state}")
+
+    return errors
+
+path_errors = validate_transitions(all_states)
+if path_errors:
+    for error in path_errors:
+        print(error)
+else:
+    print("All transitions are valid.")
+
+
+def load_game(custom_config=None, with_media=False):
+    global all_states
+    if not custom_config:
+        return gr.update(value="No custom configuration provided."), None, None, None, None, None, None
+
+    try:
+        new_config = json.loads(custom_config)
+        all_states = new_config
+
+        # Determine the starting location and state
+        starting_location = next(iter(all_states.keys()))
+        starting_state = next(iter(all_states[starting_location].keys()))
+        print(f"Starting location: {starting_location}, Starting state: {starting_state}")
+
+        game_session = GameSession(starting_location, starting_state)
+        description, choices, game_log = game_session.get_current_state_info()
+        new_path_errors = validate_transitions(all_states)
+        
+        output_media = []
+
+        if with_media:
+            media_list = all_states[starting_location][starting_state].get('media', [])
+            print(f"Media list: {media_list}")
+            
+            if media_list:
+                for media_path in media_list:
+                    #media_component = create_media_component(media_path)
+                    output_media.append(media_path)
+                print(f"Created {len(output_media)} media components")
+
+        success_message = f"Custom configuration loaded successfully!\n{new_path_errors}"
+        return (
+            gr.update(value=success_message),
+            game_log,
+            description,
+            gr.update(choices=choices),
+            gr.update(value=custom_config),
+            game_session,
+            output_media if with_media else None
+        )
+
+    except json.JSONDecodeError as e:
+        error_message = format_json_error(custom_config, e)
+        return gr.update(value=error_message), None, None, None, gr.update(value=custom_config), None, None
+
+    except Exception as e:
+        error_message = f"Error loading custom configuration: {str(e)}"
+        return gr.update(value=error_message), None, None, None, gr.update(value=custom_config), None, None
+
+def load_game_edit_version(custom_config=None, with_media=False, custom_starting_location=None, custom_starting_state=None):
+    global all_states
+    if not custom_config:
+        return gr.update(value="No custom configuration provided."), None, None, None, None, None, None
+
+    try:
+        new_config = json.loads(custom_config)
+        all_states = new_config
+
+        # Determine the starting location and state
+        if custom_starting_location and custom_starting_state:
+            if custom_starting_location not in all_states or custom_starting_state not in all_states[custom_starting_location]:
+                raise ValueError(f"Invalid custom starting point: {custom_starting_location}, {custom_starting_state}")
+            starting_location = custom_starting_location
+            starting_state = custom_starting_state
+        else:
+            starting_location = next(iter(all_states.keys()))
+            starting_state = next(iter(all_states[starting_location].keys()))
+        
+        print(f"Starting location: {starting_location}, Starting state: {starting_state}")
+
+        game_session = GameSession(starting_location, starting_state)
+        description, choices, game_log = game_session.get_current_state_info()
+        new_path_errors = validate_transitions(all_states)
+        
+        output_media = []
+
+        if with_media:
+            media_list = all_states[starting_location][starting_state].get('media', [])
+            print(f"Media list: {media_list}")
+            
+            if media_list:
+                for media_path in media_list:
+                    output_media.append(media_path)
+                print(f"Created {len(output_media)} media components")
+
+        success_message = f"Custom configuration loaded successfully!\n{new_path_errors}"
+        return (
+            gr.update(value=success_message),
+            game_log,
+            description,
+            gr.update(choices=choices),
+            gr.update(value=custom_config),
+            game_session,
+            output_media if with_media else None
+        )
+
+    except json.JSONDecodeError as e:
+        error_message = format_json_error(custom_config, e)
+        return gr.update(value=error_message), None, None, None, gr.update(value=custom_config), None, None
+
+    except Exception as e:
+        error_message = f"Error loading custom configuration: {str(e)}"
+        return gr.update(value=error_message), None, None, None, gr.update(value=custom_config), None, None
+    
+media_folder = os.path.abspath("saved_media") #make sure same as SAVE_DIR below
+
+def export_config_with_media(config_json):
+    global media_folder
+    """
+    Export the config JSON and zip it along with any files referenced in the media fields.
+    
+    :param config_json: JSON string containing the config
+    :param media_folder: Path to the folder containing media files
+    :return: Path to the created zip file
+    """
+    # Parse the JSON
+    config = json.loads(config_json)
+    
+    # Create a temporary directory to store files for zipping
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Save the config JSON to the temp directory
+        config_path = os.path.join(temp_dir, 'config.json')
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=2)
+        
+        # Collect all media files
+        media_files = set()
+        for location in config.values():
+            if isinstance(location, dict):
+                for sublocation in location.values():
+                    if isinstance(sublocation, dict) and 'media' in sublocation:
+                        media_files.update(sublocation['media'])
+        
+        # Copy media files to the temp directory
+        for media_file in media_files:
+            src_path = os.path.join(media_folder, media_file)
+            if os.path.exists(src_path):
+                dst_path = os.path.join(temp_dir, media_file)
+                shutil.copy2(src_path, dst_path)
+            else:
+                print(f"Warning: Media file not found: {media_file}")
+        
+        # Create a zip file
+        zip_path = os.path.join(os.path.dirname(media_folder), 'config_with_media.zip')
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            for root, _, files in os.walk(temp_dir):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, temp_dir)
+                    zipf.write(file_path, arcname)
+    
+    return zip_path
+
+def format_json_error(config, error):
+    lineno, colno = error.lineno, error.colno
+    lines = config.split('\n')
+    error_line = lines[lineno - 1] if lineno <= len(lines) else ""
+    pointer = ' ' * (colno - 1) + '^'
+
+    return f"""Invalid JSON format in custom configuration:
+Error at line {lineno}, column {colno}:
+{error_line}
+{pointer}
+Error details: {str(error)}"""
+
+def display_website(link):
+  html = f"<iframe src='{link}' width='100%' height='1000px'></iframe>"
+  gr.Info("If 404 then the space/page has probably been disabled - normally due to a better alternative")
+  return html
+
+initgameinfo = start_game()
+fpeinitgameinfo = start_game(new_states=finished_product_demo)

relatively_constant_variables.py

@@ -206,7 +206,14 @@ knowledge_base = [
     {"id": "doc2", "content": "Python is a popular programming language."},
     {"id": "doc3", "content": "Machine learning is a subset of artificial intelligence."},
     {"id": "doc4", "content": "The Earth orbits around the Sun."},
-    {"id": "doc5", "content": "orbits is the name of a korean fangroup"},
+    {"id": "doc5", "content": "Orbits is the name of a korean fangroup"},
+    {"id": "doc6", "content": "The capital of France is Paris. It's known for the Eiffel Tower."},
+    {"id": "doc7", "content": "The capital of Italy is Rome. It's famous for the Colosseum."},
+    {"id": "doc8", "content": "Python is a popular programming language, known for its simplicity."},
+    {"id": "doc9", "content": "Java is a widely-used programming language, valued for its portability."},
+    {"id": "doc10", "content": "Deep learning is a part of machine learning based on artificial neural networks."},
+    {"id": "doc11", "content": "Law is a Tekken character"},
+    {"id": "doc12", "content": "The law is very complicated"},
 ]
 
 #-------------------------#-------------------------#-------------------------#-------------------------
@@ -1581,6 +1588,240 @@ ExampleGameConfigs = {
         }
     },
 
+    "Eventplanningstortytest": {
+        "tavern": {
+          "start": {
+            "description": "The air crackles with anticipation as you step into the bustling event planning expo. Caterers offer tantalizing samples, florists boast breathtaking arrangements, and a charismatic DJ promises an unforgettable party atmosphere.",
+            "choices": ["approach the DJ", "sample the catering", "admire the floral displays"],
+            "transitions": {
+              "approach the DJ": "tavern_rumor",
+              "sample the catering": "tavern_grog",
+              "admire the floral displays": "tavern_start"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "rumor": {
+            "description": "The DJ, a master of hype, spins tales of legendary events he's orchestrated. He mentions a client, a mysterious socialite, planning an extravagant masked ball with a budget that could make your career.",
+            "choices": ["express your interest", "dismiss him as a showman"],
+            "transitions": {
+              "express your interest": "tavern_map",
+              "dismiss him as a showman": "tavern_start"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "grog": {
+            "description": "You savor the exquisite flavors of miniature gourmet dishes. The caterer, a true artist, describes their vision for a multi-sensory dining experience.",
+            "choices": ["inquire about their rates", "network with other attendees"],
+            "transitions": {
+              "inquire about their rates": "tavern_grog",
+              "network with other attendees": "tavern_start"
+            },
+            "media": []
+          },
+          "map": {
+            "description": "The DJ, sensing your ambition, offers a tantalizing clue: the socialite is looking for a fresh perspective. He suggests you submit a proposal, highlighting your unique vision.",
+            "choices": ["propose a themed experience", "focus on logistics and budget"],
+            "transitions": {
+              "propose a themed experience": "docks_prepare",
+              "focus on logistics and budget": "tavern_haggle"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "haggle": {
+            "description": "The DJ warns you that the socialite is notoriously demanding. \"She expects perfection,\" he cautions.",
+            "choices": ["assure him you deliver excellence", "reconsider your options"],
+            "transitions": {
+              "assure him you deliver excellence": "docks_prepare",
+              "reconsider your options": "tavern_start"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "fight": {
+            "description": "You overhear another event planner bragging about securing the masked ball contract. Jealousy burns, and you're tempted to challenge their claim.",
+            "choices": ["confront the planner", "stay focused on your goals"],
+            "transitions": {
+              "confront the planner": "tavern_victory",
+              "stay focused on your goals": "tavern_defeat"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "victory": {
+            "description": "You confront the planner, exposing their lies. The truth prevails, and word of your integrity reaches the socialite.",
+            "choices": ["prepare your proposal"],
+            "transitions": {
+              "prepare your proposal": "docks_prepare"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "defeat": {
+            "description": "You decide not to stoop to their level. Trusting your instincts, you continue networking and refining your pitch.",
+            "choices": ["continue networking"],
+            "transitions": {
+              "continue networking": "tavern_start"
+            },
+            "consequences": {},
+            "media": []
+          }
+        },
+        "docks": {
+          "prepare": {
+            "description": "Armed with a killer concept, you retreat to your studio to craft the perfect proposal. It's time to gather your team: the best florists, caterers, entertainers...",
+            "choices": ["contact your florist", "secure a caterer"],
+            "transitions": {
+              "contact your florist": "docks_ship",
+              "secure a caterer": "docks_crew"
+            },
+            "media": []
+          },
+          "ship": {
+            "description": "Your trusted florist presents a stunning array of options, from elegant orchids to whimsical fairy lights. You envision transforming the venue into a magical landscape.",
+            "choices": ["finalize the floral arrangements", "explore additional decor"],
+            "transitions": {
+              "finalize the floral arrangements": "docks_captain",
+              "explore additional decor": "docks_prepare"
+            },
+            "media": []
+          },
+          "crew": {
+            "description": "You browse through portfolios of caterers, each offering a unique culinary experience. The decision is crucial: the food must be as unforgettable as the event itself.",
+            "choices": ["choose a gourmet caterer", "opt for a themed buffet"],
+            "transitions": {
+              "choose a gourmet caterer": "docks_captain",
+              "opt for a themed buffet": "docks_captain"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "captain": {
+            "description": "With each element falling into place, your vision for the masked ball comes alive. The proposal is complete - a masterpiece of creativity and meticulous planning.",
+            "choices": ["submit your proposal"],
+            "transitions": {
+              "submit your proposal": "openSea_start"
+            },
+            "media": []
+          }
+        },
+        "openSea": {
+          "start": {
+            "description": "Days turn into nights as you await a response. The uncertainty is agonizing, your hopes rising and falling with every ring of the phone.",
+            "choices": ["check your emails obsessively", "distract yourself with another project"],
+            "transitions": {
+              "check your emails obsessively": "openSea_storm",
+              "distract yourself with another project": "openSea_mutiny"
+            },
+            "media": []
+          },
+          "storm": {
+            "description": "A wave of despair crashes over you as you receive a generic rejection email.  Your carefully crafted proposal, your dreams... dashed.",
+            "choices": ["analyze the email for feedback", "move on to the next opportunity"],
+            "transitions": {
+              "analyze the email for feedback": "openSea_ghostShip",
+              "move on to the next opportunity": "openSea_start"
+            },
+            "media": []
+          },
+          "mutiny": {
+            "description": "Your phone vibrates - an unknown number. Your heart races as you answer. It's the socialite's assistant, and they're impressed.",
+            "choices": ["accept their invitation to meet", "negotiate your terms"],
+            "transitions": {
+              "accept their invitation to meet": "openSea_ghostShip",
+              "negotiate your terms": "openSea_start"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "ghostShip": {
+            "description": "You meet the socialite - an enigmatic figure radiating elegance and power. They're intrigued by your vision, your passion.",
+            "choices": ["present your ideas in detail", "listen to their expectations"],
+            "transitions": {
+              "present your ideas in detail": "ghostShip_deck",
+              "listen to their expectations": "openSea_start"
+            },
+            "media": []
+          }
+        },
+        "ghostShip": {
+          "deck": {
+            "description": "The socialite listens intently as you unveil your plans, their eyes sparkling with approval. They love your innovative concepts, your attention to detail.",
+            "choices": ["discuss the budget and timeline", "negotiate your fee"],
+            "transitions": {
+              "discuss the budget and timeline": "ghostShip_brig",
+              "negotiate your fee": "ghostShip_quarters"
+            },
+            "media": []
+          },
+          "brig": {
+            "description": "Negotiations are swift and decisive. The socialite appreciates your professionalism and agrees to your terms. The masked ball is yours to create!",
+            "choices": ["celebrate your success", "start planning immediately"],
+            "transitions": {
+              "celebrate your success": "ghostShip_clue",
+              "start planning immediately": "ghostShip_treasure"
+            },
+            "media": []
+          },
+          "quarters": {
+            "description": "You secure a contract that exceeds your wildest dreams. The masked ball, a testament to your talent and dedication, will be your masterpiece.",
+            "choices": ["assemble your dream team", "order the first batch of champagne"],
+            "transitions": {
+              "assemble your dream team": "ghostShip_clue",
+              "order the first batch of champagne": "ghostShip_treasure"
+            },
+            "media": []
+          },
+          "clue": {
+            "description": "Excitement courses through you as you share the good news with your team. The best in the business, they're ready to help you execute this extraordinary event.",
+            "choices": ["begin the preparations"],
+            "transitions": {
+              "begin the preparations": "ghostShip_treasure"
+            },
+            "media": []
+          },
+          "treasure": {
+            "description": "Weeks of tireless work culminate in the grand opening of the masked ball. It's a triumph - a symphony of elegance, enchantment, and pure joy.",
+            "choices": ["bask in the glory of your success", "network with potential clients"],
+            "transitions": {
+              "bask in the glory of your success": "ghostShip_victory",
+              "network with potential clients": "openSea_return"
+            },
+            "consequences": {},
+            "media": []
+          },
+          "victory": {
+            "description": "The masked ball becomes legendary, exceeding all expectations. Your name is on everyone's lips, synonymous with unforgettable events.",
+            "choices": ["claim your place as an event icon"],
+            "transitions": {
+              "claim your place as an event icon": "openSea_return"
+            },
+            "consequences": {},
+            "media": []
+          }
+        },
+        "openSea_return": {
+          "return": {
+            "description": "Your star continues to rise as you orchestrate one successful event after another. Your creativity knows no bounds, your reputation solidified.",
+            "choices": ["embrace your destiny as an event maestro"],
+            "transitions": {
+              "embrace your destiny as an event maestro": "end_end"
+            },
+            "media": []
+          }
+        },
+        "end": {
+          "end": {
+            "description": "From humble beginnings at an industry expo, you've become an icon, transforming dreams into dazzling reality. The world is your canvas, and every event is a masterpiece.",
+            "choices": [],
+            "transitions": {},
+            "media": []
+          }
+        }
+      },
+
 }
 
 #-------------------------#-------------------------#-------------------------#------------------------- 
@@ -2237,7 +2478,7 @@ Interconnectedness: The graph visually demonstrates how each location, narrative
 
 )
 
-WFStage2prompt =  """Please use the below config as a template to covert the story to config format (dont use the template values like masterlocation1):
+WFStage2prompt =  """Please use the below config as a template to convert the story to config format (dont use the template values like masterlocation1):
 
 {
   "masterlocation1": {
@@ -2254,6 +2495,30 @@ WFStage2prompt =  """Please use the below config as a template to covert the sto
       "developernotes": []
     },
 
+  eg. {"tavern": {"start": {"description": "You wake up in a dimly lit tavern, the smell of ale and salt heavy in the air. A grizzled sailor at the bar boasts about a hidden island overflowing with \"more gold than ye can dream of!\" ", "choices": ["approach sailor", "ignore sailor", "order grog"], "transitions": {"approach sailor": "tavern_rumor", "ignore sailor": "tavern_start", "order grog": "tavern_grog"}, "consequences": {}, "media": []}, "rumor": {"description": "The sailor, three sheets to the wind, spins a tale of treacherous waters, ancient curses, and a map hidden on a ghost ship. He claims to know the way.", "choices": ["offer to buy him another drink", "dismiss him as a drunkard"], "transitions": {"offer to buy him another drink": "tavern_map", "dismiss him as a drunkard": "tavern_start"}, "consequences": {}, "media": []}, "grog": {"description": "The tavern keeper slides you a tankard of potent grog. It burns pleasantly as it goes down, and you feel your senses dull.", "choices": ["order another", "eavesdrop on nearby pirates"], "transitions": {"order another": "tavern_grog", "eavesdrop on nearby pirates": "tavern_start"}, "media": []}, "map": {"description": "With a wink and a hiccup, the sailor produces a crumpled piece of parchment. It's stained with salt and what looks suspiciously like blood, but the markings... they resemble a map! ", "choices": ["propose a partnership", "try to buy the map", "steal the map"], "transitions": {"propose a partnership": "docks_prepare", "try to buy the map": "tavern_haggle", "steal the map": "tavern_fight"}, "consequences": {}, "media": []}, "haggle": {"description": "The sailor eyes you shrewdly. \"This here map's worth a king's ransom,\" he slurs.", "choices": ["offer a pouch of gold", "walk away"], "transitions": {"offer a pouch of gold": "docks_prepare", "walk away": "tavern_start"}, "consequences": {}, "media": []}, "fight": {"description": "You lunge for the map, but the sailor's quicker than he looks! A brawl erupts, tables are overturned, and mugs fly through the air.", "choices": ["fight dirty", "try to reason with him"], "transitions": {"fight dirty": "tavern_victory", "try to reason with him": "tavern_defeat"}, "consequences": {}, "media": []}, "victory": {"description": "With a final blow, you knock the sailor unconscious. You grab the map and make a hasty exit.", "choices": ["head to the docks"], "transitions": {"head to the docks": "docks_prepare"}, "consequences": {}, "media": []}, "defeat": {"description": "The sailor and a couple of his cronies land some solid punches. You're tossed out of the tavern, bruised and map-less.", "choices": ["nurse your wounds"], "transitions": {"nurse your wounds": "tavern_start"}, "consequences": {}, "media": []}}, "docks": {"prepare": {"description": "The salty air of the docks fills your lungs. You can practically taste the adventure on the horizon. But first, you need a ship and a crew...", "choices": ["find a ship", "assemble a crew"], "transitions": {"find a ship": "docks_ship", "assemble a crew": "docks_crew"}, "media": []}, "ship": {"description": "You spot a sturdy-looking galleon with a \"For Sale\" sign hanging precariously from its mast.", "choices": ["inspect the ship", "look for another vessel"], "transitions": {"inspect the ship": "docks_captain", "look for another vessel": "docks_prepare"}, "media": []}, "crew": {"description": "The docks are teeming with salty dogs of all shapes and sizes.", "choices": ["recruit seasoned sailors", "round up some desperate souls"], "transitions": {"recruit seasoned sailors": "docks_captain", "round up some desperate souls": "docks_captain"}, "consequences": {}, "media": []}, "captain": {"description": "With a ship and a crew (of varying competence), you're ready to set sail! ", "choices": ["set sail for the open sea!"], "transitions": {"set sail for the open sea!": "openSea_start"}, "media": []}}, "openSea": {"start": {"description": "The open sea stretches before you, vast and unforgiving. The wind whips at your sails as you set course for the uncharted waters where the treasure awaits.", "choices": ["consult the map", "enjoy the voyage"], "transitions": {"consult the map": "openSea_storm", "enjoy the voyage": "openSea_mutiny"}, "media": []}, "storm": {"description": "A storm gathers on the horizon, dark clouds swirling ominously. Waves crash against the hull, threatening to swallow you whole.", "choices": ["weather the storm", "change course"], "transitions": {"weather the storm": "openSea_ghostShip", "change course": "openSea_start"}, "media": []}, "mutiny": {"description": "Your crew, a motley bunch at best, begin to grumble. They're growing impatient and greedy, their eyes glinting with mutiny.", "choices": ["quell the mutiny", "reason with them"], "transitions": {"quell the mutiny": "openSea_ghostShip", "reason with them": "openSea_start"}, "consequences": {}, "media": []}, "ghostShip": {"description": "Through the mist and fog, a ghostly silhouette emerges. A ship, its sails in tatters, manned by skeletal figures. This... is the ghost ship.", "choices": ["board the ghost ship", "flee"], "transitions": {"board the ghost ship": "ghostShip_deck", "flee": "openSea_start"}, "media": []}}, "ghostShip": {"deck": {"description": "You step aboard the ghost ship, the air heavy with the stench of decay. Eerie silence hangs over the vessel.", "choices": ["explore the ship", "search for the captain's quarters"], "transitions": {"explore the ship": "ghostShip_brig", "search for the captain's quarters": "ghostShip_quarters"}, "media": []}, "brig": {"description": "You stumble upon the ship's brig, its cells still occupied by skeletal remains shackled to the walls.", "choices": ["examine the skeletons", "leave the brig"], "transitions": {"examine the skeletons": "ghostShip_clue", "leave the brig": "ghostShip_deck"}, "media": []}, "quarters": {"description": "The captain's quarters are in disarray, as if a struggle took place. A tattered journal lies open on the floor.", "choices": ["read the journal", "search for the map"], "transitions": {"read the journal": "ghostShip_clue", "search for the map": "ghostShip_treasure"}, "media": []}, "clue": {"description": "You piece together clues from the journal and the skeletons. The ghost ship's captain hid the real treasure map to protect it from mutineers.", "choices": ["continue searching"], "transitions": {"continue searching": "ghostShip_treasure"}, "media": []}, "treasure": {"description": "After careful searching, you find a hidden compartment behind a portrait. Inside, a gleaming treasure chest awaits!", "choices": ["open the chest", "take the chest and flee"], "transitions": {"open the chest": "ghostShip_victory", "take the chest and flee": "openSea_return"}, "consequences": {}, "media": []}, "victory": {"description": "The treasure chest overflows with gold, jewels, and artifacts beyond your wildest dreams! You've found the legendary pirate treasure!", "choices": ["claim your prize and set sail"], "transitions": {"claim your prize and set sail": "openSea_return"}, "consequences": {}, "media": []}}, "openSea_return": {"return": {"description": "With the treasure safely stowed on your own ship, you set sail for home, leaving the ghost ship to its eternal slumber.", "choices": ["sail into the sunset"], "transitions": {"sail into the sunset": "end_end"}, "media": []}}, "end": {"end": {"description": "The sun dips below the horizon, painting the sky in hues of gold and crimson. You've cheated death, outsmarted ghosts, and claimed a fortune in pirate treasure. Your legend will be sung in taverns for centuries to come.", "choices": [], "transitions": {}, "media": []}}}
+
+The user will provide a theme 
+"""
+
+WFStage2prompt2 = """Please use the below config as a template to convert the story to config format (dont use the template values like masterlocation1):
+
+{
+  "masterlocation1": {
+    "location1": {
+      "description": "UI - Experience Bar",
+      "events": [],
+      "choices": [
+        "continue"
+      ],
+      "transitions": {
+        "continue": "masterlocation1_location2"
+      },
+      "media": [],
+      "developernotes": []
+    },
+
+ There should be 3 master and 10 total sublocations.
+ The theme is provided by the user
 """
 
 
@@ -2430,6 +2695,94 @@ TimeRelatedMermaidStoryAttempttoRefinefromtoJSON = (
 
 #-------------------------#-------------------------#-------------------------#------------------------- 
 
+finished_product_demo = {
+    'village': {
+        'start': {
+            "description": "You wake up in a small village. You hear a rumor about a lost treasure.",
+            "choices": ['explore village', 'gather supplies', 'rest'],
+            "transitions": {'explore village': 'village_rumor', 'gather supplies': 'village_supplies', 'rest': 'village_start'},
+            "consequences": {
+                'gather supplies': lambda player: player.add_item('basic supplies')
+            },
+            "media": ["testmedia/fpe_small_village.webp", "testmedia/fpe_rumor_about_a_lost_treasure.webp", "testmedia/fpe_gathering_supplies_in_a_village.webp"]
+        },
+        'rumor': {
+            "description": "You hear more details about the treasure hidden in the ancient ruins nearby.",
+            "choices": ['decide to go', 'ignore'],
+            "transitions": {'decide to go': 'village_supplies', 'ignore': 'village_start'},
+            "consequences": {
+                'decide to go': lambda player: player.update_knowledge('treasure location')
+            },
+            "media": ["testmedia/fpe_rumor_about_a_lost_treasure.webp"]
+        },
+        'supplies': {
+            "description": "You gather supplies for your journey.",
+            "choices": ['head to forest', 'stay in village'],
+            "transitions": {'head to forest': 'forest_forest', 'stay in village': 'village_start'},
+            "media": ["testmedia/fpe_person_looking_away_Listening_I_cant_hear_you_pose.webp", "testmedia/fpr_person_looking_away_Listening_hand_over_ear.webp", "testmedia/fpe_You_gather_supplies_for_your_journey.webp", "testmedia/fpe_head_to_forest.webp"]
+        },
+    },
+    'forest': {
+        'forest': {
+            "description": "You enter the dense forest, heading towards the ruins.",
+            "choices": ['travel further', 'return to village'],
+            "transitions": {'travel further': 'ruins_ruins', 'return to village': 'village_start'},
+            "media": ["testmedia/fpe_village_start_collage.png", ]
+        },
+    },
+    'ruins': {
+        'ruins': {
+            "description": "You reach the ancient ruins. The entrance is dark and eerie.",
+            "choices": ['enter ruins', 'return to forest'],
+            "transitions": {'enter ruins': 'ruins_explore', 'return to forest': 'forest_forest'},
+            "media": []
+        },
+        'explore': {
+            "description": "You explore the ruins, encountering traps and puzzles.",
+            "choices": ['solve puzzle', 'avoid traps'],
+            "transitions": {'solve puzzle': 'ruins_hiddenPassage', 'avoid traps': 'ruins_ruins'},
+            "media": []
+        },
+        'hiddenPassage': {
+            "description": "You solve a challenging puzzle and unlock a hidden passage.",
+            "choices": ['enter passage', 'go back'],
+            "transitions": {'enter passage': 'ruins_treasureRoom', 'go back': 'ruins_explore'},
+            "media": []
+        },
+        'treasureRoom': {
+            "description": "You enter the treasure room and find the treasure chest.",
+            "choices": ['take treasure', 'leave'],
+            "transitions": {'take treasure': 'ruins_celebrate', 'leave': 'ruins_ruins'},
+            "consequences": {
+                'take treasure': lambda player: player.add_item('treasure')
+            },
+            "media": []
+        },
+        'celebrate': {
+            "description": "You celebrate your discovery and decide to bring the treasure back to the village.",
+            "choices": ['return to village'],
+            "transitions": {'return to village': 'village_return'},
+            "media": []
+        },
+    },
+    'village_return': {
+        'village_return': {
+            "description": "You return to the village with the treasure and share it with the villagers.",
+            "choices": ['end adventure'],
+            "transitions": {'end adventure': 'end_end'},
+            "media": []
+        },
+    },
+    'end': {
+        'end': {
+            "description": "Your adventure ends here. The villagers are grateful and everyone's lives improve.",
+            "choices": [],
+            "transitions": {},
+            "media": []
+        },
+    }
+}
+
 
 #-------------------------#-------------------------#-------------------------#------------------------- 
 

state_prompt_fileman_UI_functions.py

@@ -0,0 +1,324 @@
+from datetime import datetime
+import json
+import os
+import gradio as gr
+from gradio_client import Client
+import shutil
+import time
+import random
+import zipfile
+import base64
+
+# Global variables
+SPFManstate = {
+    "last_file": 0,
+    "output_dir": "output",
+    "errors": [],
+    "skipped_items": [],
+    "is_paid_api": False,
+    "cost_per_item": 0.1,  # Default cost per item for paid API
+    "timestamp": datetime.now().strftime("%Y%m%d_%H%M%S"),
+    "api_provider": "default",  # Default API provider
+    "retry_delay": 300,  # 5 minutes delay for retry
+    "max_retries": 3  # Maximum number of retries
+}
+SPFManprompt_list = []
+
+#SPFMan - State, Prompt and file manager
+
+def SPFManload_state(config_file=None):
+    global SPFManstate, SPFManprompt_list
+    try:
+        if config_file:
+            with open(config_file, "r", encoding="utf-8", errors="replace") as f:
+                loaded_data = json.load(f)
+                SPFManstate.update(loaded_data.get("state", {}))
+                SPFManprompt_list = loaded_data.get("prompt_list", [])
+        elif os.path.exists("state.json"):
+            with open("state.json", "r", encoding="utf-8", errors="replace") as f:
+                loaded_data = json.load(f)
+                SPFManstate.update(loaded_data.get("state", {}))
+                SPFManprompt_list = loaded_data.get("prompt_list", [])
+    except json.JSONDecodeError as e:
+        print(f"Error decoding JSON: {e}")
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+
+def SPFMansave_state():
+    SPFManstate["timestamp"] = datetime.now().strftime("%Y%m%d_%H%M%S")
+    data_to_save = {
+        "state": SPFManstate,
+        "prompt_list": SPFManprompt_list
+    }
+    with open(f"state_{SPFManstate['timestamp']}.json", "w") as f:
+        json.dump(data_to_save, f)
+
+    # Delete old state files
+    for file in os.listdir():
+        if file.startswith("state_") and file.endswith(".json") and file != f"state_{SPFManstate['timestamp']}.json":
+            os.remove(file)
+
+def SPFManensure_output_directory():
+    os.makedirs(SPFManstate['output_dir'], exist_ok=True)
+
+def SPFMangenerate_image(prompt, retries=0):
+    SPFManensure_output_directory()
+    try:
+        client = Client("black-forest-labs/FLUX.1-dev")
+        result = client.predict(
+            prompt=prompt,
+            seed=0,
+            randomize_seed=True,
+            width=1024,
+            height=1024,
+            guidance_scale=3.5,
+            num_inference_steps=28,
+            api_name="/infer"
+        )
+        image_path = result[0]
+        filename = f"{SPFManstate['output_dir']}/{prompt[:50].replace(' ', '_')}_image_{SPFManstate['timestamp']}.webp"
+        shutil.move(image_path, filename)
+        return f"Image saved as {filename}"
+    except Exception as e:
+        error_msg = f"Error generating image: {str(e)}"
+        if "exceeded your GPU quota" in str(e) and retries < SPFManstate['max_retries']:
+            time.sleep(SPFManstate['retry_delay'])
+            return SPFMangenerate_image(prompt, retries + 1)
+        SPFManstate["errors"].append(error_msg)
+        return error_msg
+
+def SPFMangenerate_audio(prompt, retries=0):
+    SPFManensure_output_directory()
+    try:
+        client = Client("artificialguybr/Stable-Audio-Open-Zero")
+        result = client.predict(
+            prompt=prompt,
+            seconds_total=30,
+            steps=100,
+            cfg_scale=7,
+            api_name="/predict"
+        )
+
+        if isinstance(result, str) and os.path.exists(result):
+            filename = f"{SPFManstate['output_dir']}/{prompt[:50].replace(' ', '_')}_audio_{SPFManstate['timestamp']}.wav"
+            shutil.move(result, filename)
+        else:
+            audio_data = base64.b64decode(result)
+            filename = f"{SPFManstate['output_dir']}/{prompt[:50].replace(' ', '_')}_audio_{SPFManstate['timestamp']}.wav"
+            with open(filename, "wb") as audio_file:
+                audio_file.write(audio_data)
+
+        return f"Audio saved as {filename}"
+    except Exception as e:
+        error_msg = f"Error generating audio: {str(e)}"
+        if "exceeded your GPU quota" in str(e) and retries < SPFManstate['max_retries']:
+            time.sleep(SPFManstate['retry_delay'])
+            return SPFMangenerate_audio(prompt, retries + 1)
+        SPFManstate["errors"].append(error_msg)
+        return error_msg
+
+def SPFManprocess_prompts(prompt_list):
+    router = {
+        'image': SPFMangenerate_image,
+        'audio': SPFMangenerate_audio,
+    }
+    results = []
+    for prompt_type, prompt in prompt_list:
+        if prompt_type in router:
+            result = router[prompt_type](prompt)
+            results.append(result)
+            if "Error" in result:
+                break  # Stop processing if there's an error
+        else:
+            error_msg = f"Unknown prompt type: {prompt_type}"
+            SPFManstate["errors"].append(error_msg)
+            results.append(error_msg)
+            break  # Stop processing if there's an error
+    return results
+
+def SPFMancreate_files_with_generation(resume=True):
+    global SPFManstate, SPFManprompt_list
+    results = []
+
+    if resume and SPFManstate["last_file"] < len(SPFManprompt_list):
+        start = SPFManstate["last_file"]
+        results.append(f"Resuming from item {start + 1}")
+    else:
+        start = 0
+
+    end = len(SPFManprompt_list)
+
+    for i in range(start, end):
+        if i in SPFManstate["skipped_items"]:
+            results.append(f"Skipped item {i + 1}")
+            continue
+
+        prompt_type, prompt = SPFManprompt_list[i]
+
+        try:
+            if SPFManstate["is_paid_api"]:
+                generation_results = SPFManprocess_prompts([(prompt_type, prompt)])
+                results.extend(generation_results)
+            else:
+                results.append(f"Processing: {prompt_type} - {prompt}")
+                generation_results = SPFManprocess_prompts([(prompt_type, prompt)])
+                results.extend(generation_results)
+
+            if any("Error" in result for result in generation_results):
+                break  # Stop processing if there's an error
+
+            SPFManstate["last_file"] = i + 1
+        except Exception as e:
+            error_msg = f"Error processing item {i + 1}: {str(e)}"
+            SPFManstate["errors"].append(error_msg)
+            results.append(error_msg)
+            break  # Stop processing if there's an error
+
+        SPFMansave_state()
+        yield "\n".join(results)
+
+        if not SPFManstate["is_paid_api"]:
+            break  # Stop after processing one item for non-paid API
+
+def SPFManadd_prompt(prompt_type, prompt):
+    global SPFManprompt_list
+    SPFManprompt_list.append((prompt_type, prompt))
+    SPFMansave_state()
+    return f"Added {prompt_type}: {prompt}", gr.update(value=len(SPFManprompt_list))
+
+def SPFManclear_prompts():
+    global SPFManprompt_list
+    SPFManprompt_list = []
+    SPFMansave_state()
+    return "Prompt list cleared", gr.update(value=0)
+
+def SPFManview_all_prompts():
+    return "\n".join([f"{i+1}. {t}: {p}" for i, (t, p) in enumerate(SPFManprompt_list)])
+
+def SPFManzip_files():
+    SPFManensure_output_directory()
+    zip_filename = f"output_{SPFManstate['timestamp']}.zip"
+    with zipfile.ZipFile(zip_filename, 'w') as zipf:
+        for root, _, files in os.walk(SPFManstate['output_dir']):
+            for file in files:
+                zipf.write(os.path.join(root, file))
+        zipf.write(f"state_{SPFManstate['timestamp']}.json")
+
+        # Add prompt list to zip
+        prompt_list_filename = f"prompt_list_{SPFManstate['timestamp']}.txt"
+        with open(prompt_list_filename, 'w') as f:
+            for t, p in SPFManprompt_list:
+                f.write(f"{t}: {p}\n")
+        zipf.write(prompt_list_filename)
+        os.remove(prompt_list_filename)  # Remove the temporary file
+
+    return f"Files zipped as {zip_filename}"
+
+def SPFMantoggle_paid_api(value):
+    SPFManstate["is_paid_api"] = value
+    SPFMansave_state()
+    return f"Paid API: {'Enabled' if value else 'Disabled'}"
+
+def SPFManestimate_cost():
+    return f"Estimated cost: ${len(SPFManprompt_list) * SPFManstate['cost_per_item']:.2f}"
+
+def SPFManauto_generate_prompt(prompt_type):
+    subjects = ["cat", "dog", "tree", "mountain", "ocean", "city", "person", "flower", "car", "building"]
+    styles = ["realistic", "cartoon", "abstract", "vintage", "futuristic", "minimalist", "surreal", "impressionist"]
+    actions = ["running", "sleeping", "flying", "dancing", "singing", "jumping", "sitting", "laughing"]
+
+    if prompt_type == "image":
+        return f"A {random.choice(styles)} {random.choice(subjects)} {random.choice(actions)}"
+    elif prompt_type == "audio":
+        return f"Sound of a {random.choice(subjects)} {random.choice(actions)}"
+
+def SPFManview_config():
+    config = {
+        "state": SPFManstate,
+        "prompt_list_length": len(SPFManprompt_list)
+    }
+    return json.dumps(config, indent=2)
+
+def SPFManskip_item():
+    if SPFManstate["last_file"] < len(SPFManprompt_list):
+        SPFManstate["skipped_items"].append(SPFManstate["last_file"])
+        SPFManstate["last_file"] += 1
+        SPFMansave_state()
+        return f"Skipped item {SPFManstate['last_file']}"
+    return "No more items to skip"
+
+def SPFManupdate_api_details(provider, cost):
+    SPFManstate["api_provider"] = provider
+    SPFManstate["cost_per_item"] = float(cost)
+    SPFMansave_state()
+    return f"API details updated: Provider - {provider}, Cost per item - ${cost}"
+
+def SPFManload_config_file(file):
+    global SPFManstate, SPFManprompt_list
+    try:
+        # Clear existing state and prompt list
+        SPFManstate = {
+            "last_file": 0,
+            "output_dir": "output",
+            "errors": [],
+            "skipped_items": [],
+            "is_paid_api": False,
+            "cost_per_item": 0.1,
+            "timestamp": datetime.now().strftime("%Y%m%d_%H%M%S"),
+            "api_provider": "default",
+            "retry_delay": 300,
+            "max_retries": 3
+        }
+        SPFManprompt_list = []
+
+        # Check if the file is a ZIP archive
+        if file.name.endswith('.zip'):
+            # Extract the ZIP file
+            extracted_folder_path = 'extracted_files'
+            os.makedirs(extracted_folder_path, exist_ok=True)
+            with zipfile.ZipFile(file.name, 'r') as zip_ref:
+                zip_ref.extractall(extracted_folder_path)
+
+            # Find and load the state JSON file
+            json_files = [f for f in os.listdir(extracted_folder_path) if f.startswith('state_') and f.endswith('.json')]
+            if json_files:
+                json_file_path = os.path.join(extracted_folder_path, json_files[0])
+                with open(json_file_path, 'r') as json_file:
+                    loaded_data = json.load(json_file)
+                    SPFManstate.update(loaded_data.get("state", {}))
+                    SPFManprompt_list = loaded_data.get("prompt_list", [])
+
+            # Find and load the prompt list text file
+            txt_files = [f for f in os.listdir(extracted_folder_path) if f.startswith('prompt_list_') and f.endswith('.txt')]
+            if txt_files:
+                txt_file_path = os.path.join(extracted_folder_path, txt_files[0])
+                with open(txt_file_path, 'r') as txt_file:
+                    for line in txt_file:
+                        prompt_type, prompt = line.strip().split(': ', 1)
+                        SPFManprompt_list.append((prompt_type, prompt))
+
+            # Clean up extracted files
+            shutil.rmtree(extracted_folder_path)
+
+        else:
+            # Load new configuration from a single file
+            SPFManload_state(file.name)
+
+        SPFMansave_state()  # Save the loaded state
+        return f"Configuration loaded from {file.name}", gr.update(value=len(SPFManprompt_list))
+    except Exception as e:
+        return f"Error loading configuration: {str(e)}", gr.update(value=len(SPFManprompt_list))
+
+# Handle JSON input and loading
+def SPFManload_json_configuration(json_text):
+    global SPFManstate, SPFManprompt_list
+    try:
+        loaded_data = json.loads(json_text)
+        SPFManstate = loaded_data.get("state", SPFManstate)
+        SPFManprompt_list = loaded_data.get("prompt_list", SPFManprompt_list)
+        SPFMansave_state()
+        return "Configuration loaded from JSON input", gr.update(value=len(SPFManprompt_list))
+    except json.JSONDecodeError as e:
+        return f"Error parsing JSON: {str(e)}", gr.update(value=len(SPFManprompt_list))
+    except Exception as e:
+        return f"Unexpected error: {str(e)}", gr.update(value=len(SPFManprompt_list))

timeline_and_UI_generation_functions.py

@@ -0,0 +1,370 @@
+import random
+from relatively_constant_variables import player_engagement_items, story_events, all_idea_lists, existing_game_inspirations, multiplayer_features, list_names
+import json
+import gradio as gr
+import re
+import os
+
+
+def pick_random_items(items, n):
+    return random.sample(items, n)
+
+def generate_timeline(events, label):
+    timeline = []
+    for event in events:
+        timeline.append((random.randint(1, 100), label, event))
+    return timeline
+
+def create_story(timeline):
+    story = []
+    for entry in timeline:
+        if entry[1] == "Story":
+            story.append(f"The hero {entry[2].replace('engageBattle', 'engaged in a fierce battle').replace('solveRiddle', 'solved a complex riddle').replace('exploreLocation', 'explored a mysterious location')}.")
+        else:
+            story.append(f"The player interacted with {entry[2]}.")
+    return " ".join(story)
+
+def generate_story_and_timeline(no_story_timeline_points=10, no_ui_timeline_points=10, num_lists=1, items_per_list=1, include_existing_games=False, include_multiplayer=False): # , no_media_timeline_points=5, include_media=True):
+    # Pick 10 random UI items
+    random_ui_items = pick_random_items(player_engagement_items, no_ui_timeline_points)
+    random_story_items = pick_random_items(story_events, no_story_timeline_points)
+
+    # Generate UI and story timelines
+    ui_timeline = generate_timeline(random_ui_items, "UI")
+    story_timeline = generate_timeline(random_story_items, "Story")
+
+    # Initialize merged timeline with UI and story timelines
+    merged_timeline = ui_timeline + story_timeline
+    #no_media_merged_timeline = ui_timeline + story_timeline
+    #print(merged_timeline)
+    #print(no_media_merged_timeline)
+
+    # Include media-related items if specified
+    # if include_media:
+    #     media_files = generate_media_file_list(no_media_timeline_points)
+    #     #rendered_media = render_media_with_dropdowns(media_files)
+    #     media_timeline = generate_timeline(media_files, "Media")
+    #     merged_timeline += media_timeline
+
+    # print(merged_timeline)
+
+    # Sort the merged timeline based on the random numbers
+    merged_timeline.sort(key=lambda x: x[0])
+    # no_media_merged_timeline.sort(key=lambda x: x[0])
+
+    # Create the story
+    story = create_story(merged_timeline)
+
+    # Format the timeline for display
+    formatted_timeline = "\n".join([f"{entry[0]}: {entry[1]} - {entry[2]}" for entry in merged_timeline])
+    # no_media_formatted_timeline = "\n".join([f"{entry[0]}: {entry[1]} - {entry[2]}" for entry in no_media_merged_timeline])
+
+    # game_structure_with_media = generate_game_structures(formatted_timeline) #, game_structure_without_media = generate_game_structures(formatted_timeline, no_media_formatted_timeline)
+    game_structure_with_media =  convert_timeline_to_game_structure(formatted_timeline)
+
+    print("simulplay debug - good to here 4")
+
+    suggestions, selected_list_names = timeline_get_random_suggestions(num_lists, items_per_list, include_existing_games, include_multiplayer)
+
+    print("simulplay debug - good to here 4")
+
+    return formatted_timeline, story, json.dumps(game_structure_with_media, indent=2), suggestions, selected_list_names #no_media_formatted_timeline, json.dumps(game_structure_without_media, indent=2) #, game_structure_with_media
+
+media_file_types = ["image", "video", "audio"]
+
+def generate_media_file_list(n):
+    return [random.choice(media_file_types) for _ in range(n)]
+
+
+def show_elements(text):
+    # Parse the input text
+    pattern = r'(\d+): (UI|Story|Media) - (.+)'
+    blocks = re.findall(pattern, text)
+    
+    # Sort blocks by their timestamp
+    blocks.sort(key=lambda x: int(x[0]))
+    
+    outputs = []
+    
+    for timestamp, block_type, content in blocks:
+        if block_type == 'UI':
+            # Create HTML for UI elements
+            ui_html = f'<div class="ui-element">{content}</div>'
+            outputs.append(gr.HTML(ui_html))
+        elif block_type == 'Story':
+            # Display story elements as Markdown
+            outputs.append(gr.Markdown(f"**{content}**"))
+        elif block_type == 'Media':
+            if content.lower() == 'audio':
+                # Placeholder for audio element
+                outputs.append(gr.Audio(label=f"Audio at {timestamp} in the order"))
+            elif content.lower() == 'video':
+                # Placeholder for video element
+                outputs.append(gr.Video(label=f"Video at {timestamp} in the order"))
+            elif content.lower() == 'image':
+                # Placeholder for image element
+                outputs.append(gr.Image(label=f"Image at {timestamp} in the order"))
+    
+    return outputs
+
+def show_elements_json_input(json_input):
+    data = json.loads(json_input)
+    masterlocation1 = data['masterlocation1']
+    
+    outputs = []
+    
+    for location, details in masterlocation1.items():
+        if location == 'end':
+            continue
+        
+        with gr.Accordion(f"Location: {location} - Previous description {details['description']}", open=False):
+            description = gr.Textbox(label="Description", value=details['description'], interactive=True)
+            outputs.append(description)
+            
+            events = gr.Textbox(label="Events", value=json.dumps(details['events']), interactive=True)
+            outputs.append(events)
+            
+            choices = gr.Textbox(label="Choices", value=json.dumps(details['choices']), interactive=True)
+            outputs.append(choices)
+            
+            transitions = gr.Textbox(label="Transitions", value=json.dumps(details['transitions']), interactive=True)
+            outputs.append(transitions)
+            
+            # New media field
+            media = gr.Textbox(label="Media", value=json.dumps(details['media']), interactive=True)
+            outputs.append(media)
+
+            # New developernotes field
+            developernotes = gr.Textbox(label="developernotes", value=json.dumps(details['developernotes']), interactive=True)
+            outputs.append(developernotes)
+
+    #adding/removing a field means incrementing/decreasing the i+n to match the fields
+    num_current_unique_fields = 6
+    
+    def update_json(*current_values):
+        updated_data = {"masterlocation1": {}}
+        locations = [loc for loc in masterlocation1.keys() if loc != 'end']
+        for i, location in enumerate(locations):
+            updated_data["masterlocation1"][location] = {
+                "description": current_values[i*num_current_unique_fields],
+                "events": json.loads(current_values[i*num_current_unique_fields + 1]),
+                "choices": json.loads(current_values[i*num_current_unique_fields + 2]),
+                "transitions": json.loads(current_values[i*num_current_unique_fields + 3]),
+                "media": json.loads(current_values[i*num_current_unique_fields + 4]),  # New media field
+                "developernotes": json.loads(current_values[i*num_current_unique_fields + 5])
+            }
+        updated_data["masterlocation1"]["end"] = masterlocation1["end"]
+        return json.dumps(updated_data, indent=2) #json.dumps(updated_data, default=lambda o: o.__dict__, indent=2)
+    
+    update_button = gr.Button("Update JSON - Still need to copy to correct textbox to load")
+    json_output = gr.Textbox(label="Updated JSON - Still need to copy to correct textbox to load", lines=10)
+    #json_output = gr.Code(label="Updated JSON", lines=10) #Locks whole UI so use textbox
+
+    update_button.click(update_json, inputs=outputs, outputs=json_output)
+    
+    return outputs + [update_button, json_output] #, json_output_code]
+
+def show_elements_json_input_play_and_edit_version(json_input):
+    data = json.loads(json_input)
+    outputs = []
+
+    for location_name, location_data in data.items():
+        if location_name == "end":
+            continue
+
+        for sub_location, details in location_data.items():
+            with gr.Accordion(f"Location: {location_name} - {sub_location}", open=False):
+                description = gr.Textbox(label="Description", value=details.get('description', ''), interactive=True)
+                outputs.append(description)
+
+                choices = gr.Textbox(label="Choices", value=json.dumps(details.get('choices', [])), interactive=True)
+                outputs.append(choices)
+
+                transitions = gr.Textbox(label="Transitions", value=json.dumps(details.get('transitions', {})), interactive=True)
+                outputs.append(transitions)
+
+                consequences = gr.Textbox(label="Consequences", value=json.dumps(details.get('consequences', {})), interactive=True)
+                outputs.append(consequences)
+
+                media = gr.Textbox(label="Media", value=json.dumps(details.get('media', [])), interactive=True)
+                outputs.append(media)
+
+                # Add developernotes field if it exists in the config
+                if 'developernotes' in details:
+                    developernotes = gr.Textbox(label="Developer Notes", value=details.get('developernotes', ''), interactive=True)
+                    outputs.append(developernotes)
+
+    # Determine the number of fields dynamically
+    num_current_unique_fields = 5 if 'developernotes' not in next(iter(next(iter(data.values())).values())) else 6
+
+    def update_json(*current_values):
+        updated_data = {}
+        location_names = list(data.keys())
+        location_names.remove("end") if "end" in location_names else None
+
+        value_index = 0
+        for location_name in location_names:
+            updated_data[location_name] = {}
+            sub_locations = list(data[location_name].keys())
+            
+            for sub_location in sub_locations:
+                updated_data[location_name][sub_location] = {
+                    "description": current_values[value_index],
+                    "choices": json.loads(current_values[value_index + 1]),
+                    "transitions": json.loads(current_values[value_index + 2]),
+                    "consequences": json.loads(current_values[value_index + 3]),
+                    "media": json.loads(current_values[value_index + 4])
+                }
+                if num_current_unique_fields == 6:
+                    updated_data[location_name][sub_location]["developernotes"] = current_values[value_index + 5]
+                value_index += num_current_unique_fields
+
+        if "end" in data:
+            updated_data["end"] = data["end"]
+
+        return json.dumps(updated_data, indent=2)
+
+    update_button = gr.Button("Update JSON")
+    json_output = gr.Textbox(label="Updated JSON", lines=10)
+
+    update_button.click(update_json, inputs=outputs, outputs=json_output)
+
+    return outputs + [update_button, json_output]
+
+def create_media_component(file_path):
+    print(file_path)
+    _, extension = os.path.splitext(file_path)
+    extension = extension.lower()[1:]  # Remove the dot and convert to lowercase
+
+    if extension in ['jpg', 'jpeg', 'png', 'gif', 'webp']:
+        return gr.Image(value=file_path, label="Image Input")
+    elif extension in ['mp4', 'avi', 'mov']:
+        return gr.Video(value=file_path, label="Video Input")
+    elif extension in ['mp3', 'wav', 'ogg']:
+        return gr.Audio(value=file_path, label="Audio Input")
+    else:
+        return gr.Textbox(value=file_path, label=f"File: {os.path.basename(file_path)}")
+
+def convert_timeline_to_game_structure(timeline):
+    lines = timeline.split('\n')
+    game_structure = {}
+    current_location = 0
+    sub_location = 0
+
+    for i, line in enumerate(lines):
+        if line.strip() == "":
+            continue
+        
+        if line[0].isdigit():  # New location starts
+            current_location += 1
+            sub_location = 0
+            location_key = f"location{current_location}"
+            game_structure[location_key] = {
+                "description": "",
+                "events": [],
+                "choices": ["continue"],
+                "transitions": {},
+                "media": [],
+                "developernotes": []
+            }
+        else:  # Continue with sub-locations or media entries
+            sub_location += 1
+            location_key = f"location{current_location}_{sub_location}"
+        
+        # Extract the event description
+        parts = line.split(': ', 1)
+        if len(parts) == 2:
+            prefix, rest = parts
+            event_parts = rest.split(' - ', 1)
+            if len(event_parts) == 2:
+                event_type, event_description = event_parts
+            else:
+                event_type, event_description = "Unknown", rest
+        else:
+            event_type, event_description = "Unknown", line
+        
+        description = rest.strip() if event_type in ["Media", "UI"] else f"{event_type}: {event_description}"
+        
+        if sub_location == 0:
+            game_structure[f"location{current_location}"]["description"] = description
+        else:
+            game_structure[f"location{current_location}"]["events"].append({
+                "description": description,
+                "type": event_type
+            })
+        
+        # Set the transition to the next location or to the end
+        if i < len(lines) - 1:
+            next_line = lines[i + 1].strip()
+            if next_line and next_line[0].isdigit():  # New location starts
+                game_structure[f"location{current_location}"]["transitions"]["continue"] = f"masterlocation1_location{current_location + 1}"
+            else:
+                #game_structure[f"location{current_location}"]["transitions"]["continue"] = f"location_{current_location}_{sub_location + 1}"
+                game_structure[f"location{current_location}"]["transitions"]["continue"] = "end"
+        else:
+            game_structure[f"location{current_location}"]["transitions"]["continue"] = "end"
+    
+    # Add an end location
+    game_structure["end"] = {
+        "description": "The adventure ends here.",
+#         "choices": [],
+#         "transitions": {}
+        "choices": ["restart"],
+        "transitions": {"restart": "location1"}  # Assuming location_1 is the start
+
+    }
+    
+    # Wrap the game structure in master_location1
+    wrapped_structure = {"masterlocation1": game_structure}
+    
+    return wrapped_structure
+    
+# def generate_game_structures(timeline_with_media): #, timeline_without_media):
+    
+#     game_structure_with_media = convert_timeline_to_game_structure(timeline_with_media)
+#     #game_structure_without_media = convert_timeline_to_game_structure(timeline_without_media)
+    
+#     return game_structure_with_media #, game_structure_without_media
+
+
+# def timeline_get_random_suggestions(num_lists, items_per_list):
+#     """
+#     Generate random suggestions from a specified number of lists.
+    
+#     :param num_lists: Number of lists to consider
+#     :param items_per_list: Number of items to select from each list
+#     :return: A list of randomly selected suggestions
+#     """
+#     selected_lists = random.sample(all_idea_lists, min(num_lists, len(all_idea_lists)))
+#     suggestions = []
+    
+#     for lst in selected_lists:
+#         suggestions.extend(random.sample(lst, min(items_per_list, len(lst))))
+    
+#     return suggestions
+
+def timeline_get_random_suggestions(num_lists, items_per_list, include_existing_games, include_multiplayer):
+    """
+    Generate random suggestions from a specified number of lists.
+    
+    :param num_lists: Number of lists to consider
+    :param items_per_list: Number of items to select from each list
+    :param include_existing_games: Whether to include existing game inspiration lists
+    :param include_multiplayer: Whether to include multiplayer features list
+    :return: A tuple containing the list of randomly selected suggestions and the names of selected lists
+    """
+    available_lists = all_idea_lists.copy()
+    if not include_existing_games:
+        available_lists = [lst for lst in available_lists if lst not in existing_game_inspirations]
+    if not include_multiplayer:
+        available_lists = [lst for lst in available_lists if lst != multiplayer_features]
+    
+    selected_lists = random.sample(available_lists, min(num_lists, len(available_lists)))
+    suggestions = []
+    selected_list_names = []
+    
+    for lst in selected_lists:
+        suggestions.extend(random.sample(lst, min(items_per_list, len(lst))))
+        selected_list_names.append(list_names[all_idea_lists.index(lst)])
+    
+    return suggestions, selected_list_names

ui_gr_media_management.py

@@ -0,0 +1,429 @@
+import gradio as gr
+from file_explorer_and_upload import *
+from state_prompt_fileman_UI_functions import *
+from my_text_game_engine_attempt import display_website
+
+def TestGradioClientQwen270b(text):
+    # client = Client("Qwen/Qwen2-72B-Instruct")
+    # result = client.predict(
+    #         query=text, #"Hello!!",
+    #         history=[],
+    #         system="You are a helpful assistant.",
+    #         api_name="/model_chat"
+    # )
+    
+    client = Client("huggingface-projects/gemma-2-9b-it")
+    result = client.predict(
+            message=text, #"Hello!!",
+            max_new_tokens=1024,
+            temperature=0.6,
+            top_p=0.9,
+            top_k=50,
+            repetition_penalty=1.2,
+            api_name="/chat"
+    )
+    #print(result)
+
+    #print(result[1][0]) #All messages in the conversation
+    #print(result[2]) # System prompt
+    return result #result[1][0][1] # If supporting conversations this needs to return the last message instead
+
+def SPFManJLget_config_part(config_json, location, part):
+    if not config_json:
+        return {"error": "No configuration provided."}
+
+    try:
+        config = json.loads(config_json)
+        location_config = config.get(location, {})
+        return location_config.get(part, {"error": f"Part '{part}' not found in '{location}' configuration."})
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON format."}
+
+def SPFManJLupdate_location_choices(config_json):
+    if not config_json:
+        return gr.update(choices=[], value=""), gr.update(choices=[], value="")
+
+    try:
+        config = json.loads(config_json)
+        locations = list(config.keys())
+        return (gr.update(choices=locations, value=locations[0] if locations else ""),
+                gr.update(choices=[], value=""))
+    except json.JSONDecodeError:
+        return gr.update(choices=[], value=""), gr.update(choices=[], value="")
+
+def SPFManJLupdate_part_choices(config_json, location):
+    if not config_json or not location:
+        return gr.update(choices=[], value="")
+
+    try:
+        config = json.loads(config_json)
+        location_config = config.get(location, {})
+        parts = list(location_config.keys())
+        return gr.update(choices=parts, value=parts[0] if parts else "")
+    except json.JSONDecodeError:
+        return gr.update(choices=[], value="")
+    
+def SPFManJLPromptSuggestionGradClient(config, additionalnotes):
+    prompt = f"Here is a config for a game and our job is to poulate the media field to fit the context: \n{config} \nadditional information from the user: \n{additionalnotes}"
+    FinalOutput = TestGradioClientQwen270b(text=prompt)
+    
+    return FinalOutput
+
+SPFManload_state()
+
+
+def ui_gr_media_management_acc():
+    with gr.Accordion("Incomplete Media Management Assist - click to open", open=False) as filemanager:
+        gr.HTML("Make Files and Text ideas for the field and paste <br>When Space is restarted it will clear - zip export and import will be added later")
+        #with gr.Tab("Media Management Assistance"): #, open=False):
+        with gr.Accordion("Some Idea / Inspiration Sources / Demos", open=False):
+            with gr.Row():
+                gr.HTML("Licenses for the spaces still to be evaluated - June 2024 <br> Users to follow with cool spaces - <br>https://huggingface.co/osanseviero - https://huggingface.co/spaces/osanseviero/TheMLGame <br>https://huggingface.co/jbilcke-hf <br>https://huggingface.co/dylanebert <br>https://huggingface.co/fffiloni <br>https://huggingface.co/artificialguybr <br>https://huggingface.co/radames <br>https://huggingface.co/multimodalart, ")
+                gr.HTML("Some Youtube Channels to keep up with updates <br><br>https://www.youtube.com/@lev-selector <br>https://www.youtube.com/@fahdmirza/videos")
+                gr.HTML("Social media that shows possiblities <br><br>https://www.reddit.com/r/aivideo/ https://www.reddit.com/r/StableDiffusion/ https://www.reddit.com/r/midjourney/ https://x.com/blizaine https://www.reddit.com/r/singularity/comments/1ead7vp/not_sure_if_this_is_the_right_place_to_post_but_i/ https://www.reddit.com/r/singularity/comments/1ebpra6/the_big_reveal_book_trailer_made_with_runway_gen3/ https://www.reddit.com/r/LocalLLaMA/comments/1e3aboz/folks_with_one_24gb_gpu_you_can_use_an_llm_sdxl/ <br>https://www.reddit.com/r/singularity/comments/1f81ira/utilizing_ai_in_solo_game_development_my/ <br>https://www.reddit.com/r/singularity/comments/1fhe402/another_runawaymls_vid_to_vid_testing_for_first/ <br>https://www.reddit.com/r/singularity/comments/1fh08nz/runawaymls_new_videotovideo_feature_is_crazy/ <br> https://www.reddit.com/r/singularity/comments/1fe4rkv/6_chinese_ai_video_generator_comparisons_hailuo/")    
+        with gr.Accordion("Upload Files for config", open=False):
+            gr.Markdown("# Media Saver and Explorer (refresh file list to be resolved - for now upload all files and reload the space - they persist as long as the space creator doesnt reset/update the space - will add manual clear options later)")
+            with gr.Tab("Upload Files"):
+                file_input = gr.File(label="Choose File to Upload")
+                save_output = gr.Textbox(label="Upload Status")
+
+            with gr.Tab("File Explorer"):
+                
+                file_explorer = gr.FileExplorer(
+                    root_dir=SAVE_DIR,
+                    glob="*.*",
+                    file_count="single",
+                    height=300,
+                    label="Select a file to view"
+                )
+                with gr.Row():
+                    refresh_button = gr.Button("Refresh", scale=1)
+                    view_button = gr.Button("View File")
+                image_output = gr.Image(label="Image Output", type="pil")
+                audio_output = gr.Audio(label="Audio Output")
+                video_output = gr.Video(label="Video Output")
+                error_output = gr.Textbox(label="Error")
+
+            file_input.upload(
+                save_file,
+                inputs=file_input,
+                outputs=[save_output, file_explorer, file_input]
+            )
+
+            view_button.click(
+                view_file,
+                inputs=file_explorer,
+                outputs=[image_output, audio_output, video_output, error_output]
+            )
+
+            refresh_button.click(
+                refresh_file_explorer,
+                outputs=file_explorer
+            )
+
+            with gr.Tab("Batch add files to config"):
+                gr.HTML("Placeholder for Config parser to allow dropdowns for the media parts of the config inserted to make assigning media quick")
+                gr.HTML("Placeholder for Config parser to allow for current zerospace creation and placement into the config (LLM can give list of media but still have to figure out workflow from there)")
+                gr.Interface(import_config_with_media, inputs=["file"], outputs=["code", "text"], description="Uploads the files needed for your config and present config for loading somewhere else")
+
+            gr.HTML("Placeholder for clearing uploaded assets (public space and temporary persistence = sharing and space problems)")
+        
+        with gr.Tab("Using Embedded HF spaces / Premade files in external sources"):
+            gr.HTML("Generate the files and then sort and manage them in their appropriate field in the config")
+            gr.HTML("Currently - need to create then save to pc then reupload to use here in test tab")
+            gr.HTML("Whole game engine in a space? - https://huggingface.co/spaces/thomwolf/test_godot_editor <br><br> https://huggingface.co/godot-demo https://huggingface.co/spaces/thomwolf/test_godot")
+            
+            with gr.Accordion("Media Suggestions based on config"):
+                #gr.Interface( , description="Load a config and get some prompt ideas")
+                gr.HTML("Either duplicate the interface on the api side or move it out so that both sides can use it")
+            
+            with gr.Tab("Text-based"):
+                gr.HTML("Some Benchmark Leaderboards - https://huggingface.co/spaces/allenai/ZebraLogic | https://huggingface.co/spaces/allenai/WildBench https://scale.com/leaderboard https://livebench.ai")
+                with gr.Accordion("LLM HF Spaces/Sites (Click Here to Open) - Ask for a story and suggestions based on the autoconfig", open=False):
+                    with gr.Row():
+                        linktochat = gr.Dropdown(choices=[ "--Long Output--", "https://thudm-longwriter.hf.space",
+                                                        "--Function Calling--", "https://groq-demo-groq-tool-use.hf.space",
+                                                        "--Multiple Models--", "https://huggingface.co/spaces/nvidia/minitron", "https://lmsys-gpt-4o-mini-battles.hf.space", "https://labs.perplexity.ai/", "https://chat.lmsys.org", "https://sdk.vercel.ai/docs", "https://cyzgab-catch-me-if-you-can.hf.space",
+                                                        "--11B and above--",  "https://llamameta-llama3-1-405b.static.hf.space", "https://qwen-qwen-max-0428.hf.space", "https://cohereforai-c4ai-command-r-plus.hf.space", "https://qwen-qwen1-5-110b-chat-demo.hf.space",
+                                                        "--70B and above--", "https://cognitivecomputations-chat.hf.space",  "https://snowflake-snowflake-arctic-st-demo.hf.space", "https://databricks-dbrx-instruct.hf.space", "https://qwen-qwen1-5-72b-chat.hf.space",
+                                                        "--20B and above--", "https://grin-moe-demo-grin-moe.hf.space", "https://gokaygokay-gemma-2-llamacpp.hf.space", "https://01-ai-yi-34b-chat.hf.space", "https://cohereforai-c4ai-command-r-v01.hf.space", "https://ehristoforu-mixtral-46-7b-chat.hf.space", "https://mosaicml-mpt-30b-chat.hf.space",
+                                                        "--7B and above--", "https://vilarin-mistral-nemo.hf.space", "https://arcee-ai-arcee-scribe.hf.space", "https://vilarin-llama-3-1-8b-instruct.hf.space", "https://ysharma-chat-with-meta-llama3-8b.hf.space", "https://qwen-qwen1-5-moe-a2-7b-chat-demo.hf.space", "https://deepseek-ai-deepseek-coder-7b-instruct.hf.space", "https://osanseviero-mistral-super-fast.hf.space", "https://artificialguybr-qwen-14b-chat-demo.hf.space", "https://huggingface-projects-llama-2-7b-chat.hf.space",
+                                                        "--1B and above--", "https://huggingface.co/spaces/eswardivi/Phi-3-mini-128k-instruct", "https://eswardivi-phi-3-mini-4k-instruct.hf.space", "https://stabilityai-stablelm-2-1-6b-zephyr.hf.space",
+                                                        "--under 1B--", 
+                                                        "--unorganised--", "https://ysharma-zephyr-playground.hf.space", "https://huggingfaceh4-zephyr-chat.hf.space",  "https://ysharma-explore-llamav2-with-tgi.hf.space",  "https://huggingfaceh4-falcon-chat.hf.space", "https://uwnlp-guanaco-playground-tgi.hf.space", "https://stabilityai-stablelm-tuned-alpha-chat.hf.space", "https://mosaicml-mpt-7b-storywriter.hf.space", "https://huggingfaceh4-starchat-playground.hf.space", "https://bigcode-bigcode-playground.hf.space", "https://mosaicml-mpt-7b-chat.hf.space", "https://huggingchat-chat-ui.hf.space", "https://togethercomputer-openchatkit.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        chatspacebtn = gr.Button("Use the chosen URL to load interface with a chat model. For sdk.vercel click the chat button on the top left. For lymsys / chat arena copy the link and use a new tab")
+                    chatspace = gr.HTML("Chat Space Chosen will load here")
+                    chatspacebtn.click(display_website, inputs=linktochat, outputs=chatspace)
+
+            with gr.Tab("Media Understanding"):
+                gr.HTML("NPC Response Engines? Camera, Shopkeeper, Companion, Enemies, etc.")
+                with gr.Accordion("Media understanding model Spaces/Sites (Click Here to Open)", open=False):
+                    with gr.Row():
+                        linktomediaunderstandingspace = gr.Dropdown(choices=[ "--Weak Audio Understanding = Audio to text, Weak Video Understanding = Video to Image to Image Understanding", "https://skalskip-florence-2-video.hf.space", "https://kingnish-opengpt-4o.hf.space",
+                                                                                "--Audio Understanding--", "https://jan-hq-llama3-1-s-v0-2.hf.space",
+                                                                                "--Video Understanding--", "https://ivgsz-flash-vstream-demo.hf.space",
+                                                                                "--Image Understanding--", "https://gokaygokay-flux-prompt-generator.hf.space", "https://gokaygokay-florence-2.hf.space", "https://vilarin-vl-chatbox.hf.space", "https://qnguyen3-nanollava.hf.space", "https://skalskip-better-florence-2.hf.space", "https://merve-llava-interleave.hf.space", 
+                                                                                "--Img-to-img Understanding--", "https://merve-draw-to-search-art.hf.space", 
+                                                                                "--Image Understanding without conversation--", "https://epfl-vilab-4m.hf.space", "https://epfl-vilab-multimae.hf.space", "https://gokaygokay-sd3-long-captioner.hf.space" ],
+                                                        label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        mediaunderstandingspacebtn = gr.Button("Use the chosen URL to load interface with a media understanding space")
+                    mediaunderstandingspace = gr.HTML("Mdeia Understanding Space Chosen will load here")
+                    mediaunderstandingspacebtn.click(display_website, inputs=linktomediaunderstandingspace, outputs=mediaunderstandingspace)
+                gr.HTML("Image Caption =  https://huggingface.co/spaces/microsoft/Promptist (Prompt Lengthen) ")
+
+
+            with gr.Tab("Images"):
+                with gr.Accordion("Image Gen or Animation HF Spaces/Sites (Click Here to Open) - Have to download and upload at the the top", open=False):
+                    # with gr.Tabs("General"):
+                    with gr.Row():
+                        linktoimagegen = gr.Dropdown(choices=["--Text-Interleaved--", "https://ethanchern-anole.hf.space",
+                                                                "--Hidden Image--", "https://ap123-illusiondiffusion.hf.space",
+                                                                "--Panorama--", "https://gokaygokay-360panoimage.hf.space",
+                                                                "--General--", "https://pixart-alpha-pixart-sigma.hf.space", "https://stabilityai-stable-diffusion-3-medium.hf.space", "https://prodia-sdxl-stable-diffusion-xl.hf.space", "https://prodia-fast-stable-diffusion.hf.space", "https://bytedance-hyper-sdxl-1step-t2i.hf.space",  "https://multimodalart-cosxl.hf.space", "https://cagliostrolab-animagine-xl-3-1.hf.space", "https://stabilityai-stable-diffusion.hf.space",
+                                                                "--Speed--", "https://radames-real-time-text-to-image-sdxl-lightning.hf.space", "https://ap123-sdxl-lightning.hf.space",
+                                                                "--LORA Support--", "https://multimodalart-flux-lora-the-explorer.hf.space", "https://artificialguybr-artificialguybr-demo-lora.hf.space", "https://artificialguybr-studio-ghibli-lora-sdxl.hf.space", "https://artificialguybr-pixel-art-generator.hf.space", "https://fffiloni-sdxl-control-loras.hf.space", "https://ehristoforu-dalle-3-xl-lora-v2.hf.space",
+                                                                "--Image to Image--", "https://gokaygokay-kolorsplusplus.hf.space", "https://lllyasviel-ic-light.hf.space", "https://gparmar-img2img-turbo-sketch.hf.space",
+                                                                "--Upscaler--", "https://gokaygokay-tile-upscaler.hf.space",
+                                                                "--Control of Pose--", "https://instantx-instantid.hf.space", "https://modelscope-transferanything.hf.space", "https://okaris-omni-zero.hf.space"
+                                                                "--Control of Shapes--", "https://linoyts-scribble-sdxl-flash.hf.space",
+                                                                "--Control of Text--", "",
+                                                                "--Clothing Try on demos--", "https://kwai-kolors-kolors-virtual-try-on.hf.space",
+                                                                "--Foreign Language Input--", "https://gokaygokay-kolors.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        imagegenspacebtn = gr.Button("Use the chosen URL to load interface with a image generation model")
+                
+                    imagegenspace = gr.HTML("Image Space Chosen will load here")
+                    imagegenspacebtn.click(display_website, inputs=linktoimagegen, outputs=imagegenspace)
+                
+                linkstobecollectednoembed = "https://artgan-diffusion-api.hf.space", "https://multimodalart-stable-cascade.hf.space", "https://google-sdxl.hf.space", "https://visionmaze-magic-me.hf.space", "https://segmind-segmind-stable-diffusion.hf.space", "https://simianluo-latent-consistency-model.hf.space",
+                gr.HTML("Concept Art, UI elements, Static/3D Characters, Environments and Objects")
+                gr.HTML("Images Generation General (3rd Party) =  https://www.craiyon.com/")
+                gr.HTML("Images Generation Posters with text - https://huggingface.co/spaces/GlyphByT5/Glyph-SDXL-v2")
+                gr.HTML("SVG Generation = Coding models / SOTA LLM ")
+                gr.HTML("Images Generation - Upscaling - https://huggingface.co/spaces/gokaygokay/Tile-Upscaler")
+                gr.HTML("Vision Models for descriptions <br> https://huggingface.co/spaces/gokaygokay/Florence-2 <br>https://huggingface.co/spaces/vilarin/VL-Chatbox - glm 4v 9b <br>")
+                gr.HTML("Upscalers (save data transfer costs? highly detailed characters?) - https://huggingface.co/spaces/gokaygokay/AuraSR")
+                gr.HTML("Placeholder for huggingface spaces that can assist ")
+                gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
+
+            with gr.Tab("Video"):
+                with gr.Accordion("Video Spaces/Sites (Click Here to Open)", open=False):
+                    with gr.Row():
+                        linktovideogenspace = gr.Dropdown(choices=["--Texttovid--", "https://kingnish-instant-video.hf.space",
+                                                                "--General--", "https://zheyangqin-vader.hf.space", "https://kadirnar-open-sora.hf.space",
+                                                                "--Talking Portrait--", "https://fffiloni-tts-hallo-talking-portrait.hf.space",  
+                                                                "--Gif / ImgtoImg based video--", "https://wangfuyun-animatelcm-svd.hf.space", "https://bytedance-animatediff-lightning.hf.space", "https://wangfuyun-animatelcm.hf.space", "https://guoyww-animatediff.hf.space",], 
+                                                        label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        videogenspacebtn = gr.Button("Use the chosen URL to load interface with video generation")
+                    videogenspace = gr.HTML("Video Space Chosen will load here")
+                    videogenspacebtn.click(display_website, inputs=linktovideogenspace, outputs=videogenspace)
+
+                gr.HTML("Cutscenes, Tutorials, Trailers")
+                gr.HTML("Portrait Video eg. Solo Taking NPC - https://huggingface.co/spaces/fffiloni/tts-hallo-talking-portrait (Image + Audio and combination)  https://huggingface.co/spaces/KwaiVGI/LivePortrait (Non verbal communication eg. in a library, when running from a pursuer)")
+                gr.HTML("Placeholder for huggingface spaces that can assist - https://huggingface.co/spaces/KingNish/Instant-Video, https://huggingface.co/spaces/multimodalart/stable-video-diffusion, https://huggingface.co/spaces/multimodalart/stable-video-diffusion")
+                gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
+                gr.HTML("3rd Party / Closed Source - https://runwayml.com/ <br>")
+                with gr.Tab("Animations (for lower resource use)"):
+                    gr.HTML("Characters, Environments, Objects")
+                    gr.HTML("Placeholder for huggingface spaces that can assist - image as 3d object in video https://huggingface.co/spaces/ashawkey/LGM")
+                    gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
+
+            with gr.Tab("Audio"):
+                with gr.Accordion("Audio Spaces/Sites (Click Here to Open)", open=False):
+                    with gr.Row():
+                        linktoaudiogenspace = gr.Dropdown(choices=["General", "https://artificialguybr-stable-audio-open-zero.hf.space", "",
+                                                                    "--Talking Portrait--","https://fffiloni-tts-hallo-talking-portrait.hf.space"], 
+                                                        label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        audiogenspacebtn = gr.Button("Use the chosen URL to load interface with audio generation")
+                    audiogenspace = gr.HTML("Audio Space Chosen will load here")
+                    audiogenspacebtn.click(display_website, inputs=linktoaudiogenspace, outputs=audiogenspace)
+                gr.HTML("Music - Background, Interactive, Cutscene, Menu <br>Sound Effects - Environment, character, action (environmental triggered by user eg. gun), UI <br>Speech - Dialouge, narration, voiceover <br>The new render function means the Config can be made and iframe/api functions can be ordered as neccessary based on the part of the config that needs it to streamline workflows based on current state of config ")
+                gr.HTML("Placeholder for huggingface spaces that can assist")
+                gr.HTML("Audio Sound Effects - https://huggingface.co/spaces/artificialguybr/Stable-Audio-Open-Zero")
+                gr.HTML("Voices - Voice clone eg. actors part of your project - https://huggingface.co/spaces/tonyassi/voice-clone")
+                gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
+                gr.HTML("3rd Party / Closed Source - https://suno.com/ <br>https://www.udio.com/")
+
+            with gr.Tab("3D"):
+                with gr.Accordion("3D Model Spaces/Sites (Click Here to Open)", open=False):
+                    with gr.Row():
+                        linktoThreedModel = gr.Dropdown(choices=["--Image prompt--", "https://vast-ai-charactergen.hf.space"
+                                                                "--Video prompt--", "https://facebook-vggsfm.hf.space",
+                                                                "--Text prompt--", "https://wuvin-unique3d.hf.space", "https://stabilityai-triposr.hf.space", "https://hysts-shap-e.hf.space", "https://tencentarc-instantmesh.hf.space", "https://ashawkey-lgm.hf.space", "https://dylanebert-lgm-mini.hf.space", "https://dylanebert-splat-to-mesh.hf.space", "https://dylanebert-multi-view-diffusion.hf.space"], label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        ThreedModelspacebtn = gr.Button("Use the chosen URL to load interface with a 3D model")
+                    ThreedModelspace = gr.HTML("3D Space Chosen will load here")
+                    ThreedModelspacebtn.click(display_website, inputs=linktoThreedModel, outputs=ThreedModelspace)
+                gr.HTML("Characters, Environments, Objects")
+                gr.HTML("Placeholder for huggingface spaces that can assist - https://huggingface.co/spaces/dylanebert/3d-arena")
+                gr.HTML("Closed Source - https://www.meshy.ai/")
+
+            with gr.Tab("Fonts"):
+                gr.HTML("Style of whole game, or locations, or characters")
+                gr.HTML("Placeholder for huggingface spaces that can assist - there was a space that could make letter into pictures based on the prompt but I cant find it now")
+                gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
+            
+            with gr.Tab("Shaders and related"):
+                with gr.Accordion("'Special Effects' Spaces/Sites (Click Here to Open)", open=False):
+                    with gr.Row():
+                        linktospecialeffectsgenspace = gr.Dropdown(choices=["--Distorted Image--", "https://epfl-vilab-4m.hf.space", "https://epfl-vilab-multimae.hf.space"], 
+                                                        label="Choose/Cancel type any .hf.space link here (can also type a link)'", allow_custom_value=True)
+                        specialeffectsgenspacebtn = gr.Button("Use the chosen URL to load interface with special effects generation")
+                    specialeffectsgenspace = gr.HTML("Special Effects Space Chosen will load here")
+                    specialeffectsgenspacebtn.click(display_website, inputs=linktospecialeffectsgenspace, outputs=specialeffectsgenspace)
+                gr.HTML("Any output that is not understood by the common person can be used as special effects eg. depth map filters on images etc.")
+                gr.HTML("Post-processing Effects, material effects, Particle systems, visual feedback")
+                gr.HTML("Visual Effects - eg. explosion can turn all items white for a moment, losing conciousness blurs whole screen")
+                gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
+            
+            with gr.Tab("NPCS"):
+                gr.HTML("For ideas on NPCS check: https://lifearchitect.ai/leta/, ")
+            with gr.Tab("Save files"):
+                gr.HTML("For Dynamic events overnight or when player is not active what can LLMS edit? <br><br>eg. Waiting for a letter from a random npc can be decided by the llm <br>eg. Improved Stats on certain days (eg. bitrthday) <br>Privacy <br>User Directed DLC eg. Rockstar Editor with local llm guide")
+                gr.HTML("Some ideas - In game websites eg. GTA esp stock markets, news; ")
+                gr.HTML("Placeholder for huggingface spaces that can assist - https://huggingface.co/nvidia/Nemotron-4-340B-Instruct (Purpose is supposed to be synthetic data generation), https://huggingface.co/spaces/gokaygokay/Gemma-2-llamacpp ")
+                gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist (9b and under) <br>initial floor for testing can be https://huggingface.co/spaces/Qwen/Qwen2-0.5B-Instruct, https://huggingface.co/spaces/Qwen/Qwen2-1.5b-instruct-demo, https://huggingface.co/spaces/stabilityai/stablelm-2-1_6b-zephyr, https://huggingface.co/spaces/IndexTeam/Index-1.9B, https://huggingface.co/microsoft/Phi-3-mini-4k-instruct")
+            with gr.Tab("Diagrams"):
+                gr.HTML("Claude 3.5 sonnet is very good with mermaid graphs - can used for maps, situational explanations")
+            with gr.Tab("Maths"):
+                gr.HTML("https://huggingface.co/spaces/AI-MO/math-olympiad-solver")
+        
+        with gr.Tab("Using gradio client / External Source as API provider"):
+            gr.HTML("State file managed and one item at time creation using gradio client")
+            with gr.Tab("Bulk Generate Assets"):
+                with gr.Tab("Load Configuration"):
+                    with gr.Row():
+                        SPFManconfig_file = gr.File(label="Load Configuration File")
+                        SPFManload_config_button = gr.Button("Load Configuration")
+                        SPFManload_result = gr.Textbox(label="Load Result")
+
+                with gr.Tab("Manage Prompts"):
+                    with gr.Accordion("Load the current game state that you want to add media to", open=False):
+                        gr.Markdown("# Load and View Game Configuration")
+
+                        with gr.Accordion("Click to hide config for space"):
+                            SPFManJLconfig_input = gr.Textbox(label="Enter Game Configuration JSON", placeholder="Paste JSON config here", lines=4)
+                        SPFManJLlocation_choice = gr.Dropdown(choices=[], label="Choose location")
+                        SPFManJLpart_choice = gr.Dropdown(choices=[], label="Choose part")
+                        SPFManJLconfig_view = gr.JSON(label="Configuration Details")
+
+                        SPFManJLconfig_input.change(fn=SPFManJLupdate_location_choices, inputs=SPFManJLconfig_input, outputs=[SPFManJLlocation_choice, SPFManJLpart_choice])
+                        SPFManJLlocation_choice.change(fn=SPFManJLupdate_part_choices, inputs=[SPFManJLconfig_input, SPFManJLlocation_choice], outputs=SPFManJLpart_choice)
+
+                        def SPFManJLupdate_config_view(config_json, location, part):
+                            return SPFManJLget_config_part(config_json, location, part)
+
+                        SPFManJLpart_choice.change(fn=SPFManJLupdate_config_view, inputs=[SPFManJLconfig_input, SPFManJLlocation_choice, SPFManJLpart_choice], outputs=SPFManJLconfig_view)
+
+                    gr.Interface(SPFManJLPromptSuggestionGradClient, inputs=[SPFManJLconfig_view, "text"], outputs=["text"], description="Ask a random LLM for suggestions eg. bring life to the game by focusing more on the description")    
+
+                    with gr.Row():
+                        SPFManprompt_type = gr.Dropdown(["image", "audio"], label="Prompt Type")
+                        SPFManprompt = gr.Textbox(label="Prompt")
+                    with gr.Row():
+                        SPFManadd_button = gr.Button("Add Prompt")
+                        SPFManclear_button = gr.Button("Clear Prompts")
+                        SPFManauto_generate_button = gr.Button("Auto-Generate Prompt")
+                    with gr.Row():
+                        SPFManprompt_output = gr.Textbox(label="Added Prompts")
+                        SPFManprompt_count = gr.Number(value=0, label="Number of Prompts")
+                        SPFManview_prompts_button = gr.Button("View All Prompts")
+                    SPFManall_prompts_output = gr.Textbox(label="All Prompts", lines=10)
+                    #SPFManconfig_view = gr.Textbox(label="Current Configuration", lines=10)
+
+                    # New JSON input for loading configurations
+                    #SPFManjson_input = gr.Textbox(label="JSON Configuration", lines=10)
+                    #SPFManload_json_button = gr.Button("Load JSON Configuration")
+
+                    # Link the button to the function
+                    #SPFManload_json_button.click(SPFManload_json_configuration, inputs=[SPFManjson_input], outputs=[load_result, prompt_count])
+
+                with gr.Tab("API Settings"):
+                    with gr.Row():
+                        SPFManapi_provider = gr.Textbox(label="API Provider", value=lambda: SPFManstate["api_provider"])
+                        SPFMancost_per_item = gr.Number(label="Cost per Item", value=lambda: SPFManstate["cost_per_item"])
+                    SPFManupdate_api_button = gr.Button("Update API Details")
+                    SPFManapi_update_result = gr.Textbox(label="API Update Result")
+
+                with gr.Tab("Generate Files and Media"):
+                    with gr.Row():
+                        SPFManoutput_dir = gr.Textbox(label="Output Directory", value=lambda: SPFManstate["output_dir"])
+                        SPFManresume = gr.Checkbox(label="Resume from last run", value=True)
+                    with gr.Row():
+                        SPFManpaid_api_checkbox = gr.Checkbox(label="Use Paid API", value=lambda: SPFManstate["is_paid_api"])
+                        SPFMancost_estimate = gr.Textbox(label="Estimated Cost")
+                    SPFMangenerate_button = gr.Button("Generate Files and Media")
+                    SPFManskip_button = gr.Button("Skip Current Item")
+                    SPFManresults = gr.Textbox(label="Results", lines=10)
+                    SPFManerror_output = gr.Textbox(label="Errors", lines=5)
+                    SPFManzip_button = gr.Button("Zip Output Files")
+                    SPFManzip_result = gr.Textbox(label="Zip Result")
+
+                SPFManload_config_button.click(SPFManload_config_file, inputs=[SPFManconfig_file], outputs=[SPFManload_result, SPFManprompt_count])
+                SPFManadd_button.click(SPFManadd_prompt, inputs=[SPFManprompt_type, SPFManprompt], outputs=[SPFManprompt_output, SPFManprompt_count])
+                SPFManclear_button.click(SPFManclear_prompts, outputs=[SPFManprompt_output, SPFManprompt_count])
+                SPFManview_prompts_button.click(SPFManview_all_prompts, outputs=SPFManall_prompts_output)
+                SPFManauto_generate_button.click(SPFManauto_generate_prompt, inputs=[SPFManprompt_type], outputs=[SPFManprompt])
+                SPFManupdate_api_button.click(SPFManupdate_api_details, inputs=[SPFManapi_provider, SPFMancost_per_item], outputs=[SPFManapi_update_result])
+                SPFManpaid_api_checkbox.change(SPFMantoggle_paid_api, inputs=[SPFManpaid_api_checkbox], outputs=[SPFMancost_estimate])
+                SPFMangenerate_button.click(SPFMancreate_files_with_generation, inputs=[SPFManresume], outputs=SPFManresults)
+                SPFManskip_button.click(SPFManskip_item, outputs=SPFManresults)
+                SPFManzip_button.click(SPFManzip_files, outputs=SPFManzip_result)
+                gr.Textbox(label="Configuration", value=SPFManview_config, every=1)
+
+            with gr.Tab("Replicate - API Definitions crucial models"):
+                gr.HTML("Many custom models set-up and the ability to set up the neccesary ones using cog <br> https://replicate.com/collections/text-to-image | https://replicate.com/collections/text-to-video | https://replicate.com/collections/audio-generation https://replicate.com/collections/text-to-speech | https://replicate.com/collections/3d-models ")
+                gr.Code("""Install Replicate’s Python client library
+pip install replicate
+
+Copy
+Set the REPLICATE_API_TOKEN environment variable
+export REPLICATE_API_TOKEN=<paste-your-token-here>
+
+Visibility
+
+Copy
+Find your API token in your account settings.
+
+Import the client
+import replicate
+
+Copy
+Run meta/musicgen using Replicate’s API. Check out the model's schema for an overview of inputs and outputs.
+
+output = replicate.run(
+    "meta/musicgen:671ac645ce5e552cc63a54a2bbff63fcf798043055d2dac5fc9e36a837eedcfb",
+    input={
+        "top_k": 250,
+        "top_p": 0,
+        "prompt": "Edo25 major g melodies that sound triumphant and cinematic. Leading up to a crescendo that resolves in a 9th harmonic",
+        "duration": 8,
+        "temperature": 1,
+        "continuation": False,
+        "model_version": "stereo-large",
+        "output_format": "mp3",
+        "continuation_start": 0,
+        "multi_band_diffusion": False,
+        "normalization_strategy": "peak",
+        "classifier_free_guidance": 3
+    }
+)
+print(output)""", language="python")
+                
+                with gr.Tab("Cloud Computing"):
+                    gr.HTML("Storage, AI api access, VMs, ")
+
+
+        with gr.Tab("Using 3rd Party Interface - free/paid"):
+            gr.HTML("General - https://artificialanalysis.ai/models/llama-3-1-instruct-405b/providers")
+            gr.HTML("Image - https://playground.com/login | https://www.midjourney.com/showcase")
+            gr.HTML("Audio - https://www.udio.com/home https://www.udio.com/pricing | https://suno.com/ ")
+            gr.HTML("Video - https://lumalabs.ai/dream-machine https://lumalabs.ai/dream-machine/pricing (free 30 gens a month) | https://klingai.com/ - https://www.reddit.com/r/singularity/comments/1fk4tgp/kling_ai_showcasing_the_use_of_the_motion_brush/ | https://www.hedra.com/")
+            gr.HTML("3D - https://www.csm.ai/ | https://www.tripo3d.ai/ | https://zoo.dev/text-to-cad")
+            gr.HTML("Multiple - https://fal.ai/pricing | ")
+
+        with gr.Tab("Examples of Generated Media on Reddit"):
+            gr.HTML("https://www.reddit.com/r/singularity/comments/1fknejj/facecamai_lets_anyone_convert_a_single_image_into/ <br>https://www.reddit.com/r/singularity/comments/1fjylow/tripo_v20_is_out_now_you_can_create_stunning_3d/")
+
+        with gr.Tab("Licensing"):
+                gr.HTML("Need to find the press release to see license eg. https://blackforestlabs.ai/announcing-black-forest-labs/")
+
+    return filemanager