awacke1/WordGameAI · Language Templates Prompt Example

Its difficult for language systems to generate detailed code on specific features that are recently and generally designed and specified. One way to do this is by ten shot injection which defines a format and sequence like method steps of play to fill in like a form or replacement system.

I have a ten point prompt which controls the high information words used to generate effective python streamlit apps. Please revise it to define and implement short samples using the libraries I include below. Desired Output Format (match this for output but change content): WordGamePython2="""Generate 10 high-information words related to word game programming in Python, used in context with emojis:

🐍 Python: A high-level programming language known for its simplicity and readability.
📜 String: A data type used to represent text, essential for handling words in a word game.
🎲 Random: A Python module that generates random numbers, useful for letter selection or AI opponents.
📝 Input: A function that allows players to enter their words or actions through the command line.
📊 List: A data structure that stores multiple elements, handy for managing game components like letters or words.
🔍 Validation: The process of checking if a word entered by a player is valid according to the game rules.
🔄 Loop: A programming construct that allows repeated execution of code, useful for turn-based gameplay.
🎨 Pygame: A popular Python library for creating games with graphics and sound.
💾 File I/O: Reading from and writing to files, useful for storing game data like high scores or word lists.
🤖 AI: Implementing artificial intelligence techniques to create computer-controlled opponents in word games.""" Choose a new top 10 from the list of imports below and feature a one liner code example. Only use libraries where you can demonstrate a good python/streamlit one liner of sample implementation for a word game: import streamlit as st

import streamlit.components.v1 as components

import os

import json

import random

import base64

import glob

import math

import openai

import pytz

import re

import requests

import textract

import time

import zipfile

import huggingface_hub

import dotenv

from audio_recorder_streamlit import audio_recorder

from bs4 import BeautifulSoup

from collections import deque

from datetime import datetime

from dotenv import load_dotenv

from huggingface_hub import InferenceClient

from io import BytesIO

from openai import ChatCompletion

from PyPDF2 import PdfReader

from templates import bot_template, css, user_template

from xml.etree import ElementTree as ET

from PIL import Image

from urllib.parse import quote # Ensure this import is included

import streamlit as st

def light_enters_eyes(text):
return f"👀 Light enters the child's eyes, carrying the visual information: {text}"

def retina_captures_info(text):
return f"📸 The retina captures the visual information: {text}"

def ganglion_cells_compress(text):
compressed_text = text[:15] if len(text) > 15 else text
return f"🌐 Ganglion cells compress the visual data: {compressed_text}"

def optic_nerve_carries(compressed_text):
return f"🧠 The optic nerve carries the compressed visual information: {compressed_text}"

def lgn_processes(compressed_text):
return f"🔍 The lateral geniculate nucleus (LGN) processes the visual data: {compressed_text}"

def visual_cortex_receives(compressed_text):
return f"🖼️ The visual cortex receives the information from the LGN: {compressed_text}"

def visual_cortex_processes(compressed_text):
return f"🧩 Different areas of the visual cortex process specific aspects of the visual information: {compressed_text}"

def integrate_and_send(compressed_text):
return f"🔄 The processed visual data is integrated and sent to other brain regions: {compressed_text}"

def form_associations(compressed_text):
return f"💡 The child's developing brain forms associations based on the visual information: {compressed_text}"

def store_visual_memory(compressed_text):
return f"💾 The processed visual data is stored as a visual memory: {compressed_text}"

def main():
st.title("4-Year-Old Child's Visual Information Processing")
text_input = st.text_input("Enter the visual information:")

if text_input:
    st.write(light_enters_eyes(text_input))
    st.write(retina_captures_info(text_input))
    compressed_text = ganglion_cells_compress(text_input)
    st.write(compressed_text)
    st.write(optic_nerve_carries(compressed_text))
    st.write(lgn_processes(compressed_text))
    st.write(visual_cortex_receives(compressed_text))
    st.write(visual_cortex_processes(compressed_text))
    st.write(integrate_and_send(compressed_text))
    st.write(form_associations(compressed_text))
    st.write(store_visual_memory(compressed_text))

if name == "main":
main()