game gen

app.py

@@ -5,13 +5,13 @@ from io import BytesIO
 from dotenv import load_dotenv
 from openai.embeddings_utils import get_embedding, cosine_similarity
 from slack_processing.slack_data_prep import FetchSlack, ProcessSlack, CreateEmbeddings
+from create_games.create_games_slack import CreateGames
 ##from ml_to_nl_translation.translation import getTranslations, getJSONDF
 #from lookups.translate_pdf_to_text import PreparePDF
 #from lookups.create_searchable_content import CreateSearchableContent
 from utilities import api_keys
 import PyPDF2
 
-
 import pkg_resources
 dotenv_version = pkg_resources.get_distribution("tiktoken").version
 print(f"tiktoken version: {dotenv_version}")
@@ -38,13 +38,10 @@ def FetchEmbeddings():
      print(result)
      return result
 
-def fetch_reference():
-     #result = PreparePDF()
-     print("Result"+result)
-     return result
-
-def fetch_content():
-    # result = CreateSearchableContent()
+def FetchGames():
+     result = CreateGames()
+     print("result")
+     print(result)
      return result
 
 with gr.Blocks() as ui1:
@@ -77,7 +74,7 @@ with gr.Blocks() as ui4:
     with gr.Row():
         with gr.Column(scale=1, min_width=600):
             df4 =gr.Dataframe(type="pandas")
-    b4.click(fetch_content,outputs=df4)
+    b4.click(FetchGames,outputs=df4)
 
 demo = gr.TabbedInterface([ui1,ui2,ui3,ui4], ("Fetch Slack", "Process & Tag", "Create Embeddings", "Find Games"))
 demo.launch()

create_games/create_games_slack.py

@@ -0,0 +1,209 @@
+import pandas as pd
+import numpy as np
+import openai, os, tiktoken, json
+import importlib.util
+from openai.embeddings_utils import cosine_similarity, get_embedding
+from sklearn.metrics import classification_report, PrecisionRecallDisplay
+from collections import Counter
+from nltk.corpus import wordnet
+from nltk.tokenize import word_tokenize
+import random
+
+INPUT_DATAPATH = "slack_processing/data/themes.json"
+OUTPUT_GAME_IDEAS_DATAPATH="create_games/data/game_ideas.json"
+themes = []
+themes_by_person={}
+people_by_theme = {}
+
+def ReadThemesFromFile():
+    global themes
+    with open(INPUT_DATAPATH, "r") as json_file:
+        themes = json.load(json_file)
+    print("done reading")
+
+def PopulateThemesByPerson():
+    global themes, themes_by_person
+    print("*** themes:")
+    print (themes)
+    themes_by_person = {}
+    for theme in themes:
+        person = theme['person']
+        postId = theme['postId']
+        theme_info = (theme['theme'], postId)
+        themes_by_person.setdefault(person, set()).add(theme_info)
+
+def PrintThemesByPerson():
+    print("PrintThemesByPerson")
+    global themes_by_person
+    print("Themes by person: ")
+    print (themes_by_person)
+    for person, person_themes in themes_by_person.items():
+        print(f"Themes associated with {person}:")
+        print("Person themes:", person_themes)  # Add this line to debug
+        for theme in person_themes:
+            print(f"Theme: {theme}")
+
+def PopulatePeopleByThemes():
+    global themes, people_by_theme
+    people_by_theme = {}
+    for theme in themes:
+        person = theme['person']
+        theme_name = theme['theme']
+        people_by_theme.setdefault(theme_name, set()).add(person)
+
+def PrintPeopleByThemes():
+    print("PrintPeopleByThemes")
+    global people_by_theme
+    print ("-- people by theme --")
+    print (people_by_theme)
+    for theme, people in people_by_theme.items():
+        print(f"Theme: {theme}")
+        print("People:", people)
+
+def CreateRandomGroup(group_size):
+    global themes
+    # Extract all unique people from the theme list
+    people = list(set(theme['person'] for theme in themes))
+    # Check if the group size is larger than the available people
+    if group_size > len(people):
+        print("Group size is larger than the available number of people.")
+        return None
+    # Randomly select a group of people
+    random_group = random.sample(people, group_size)
+    return random_group
+
+def FindOverlappingTopics(people):
+    global themes_by_person
+    if not people:
+        print("No people provided.")
+        return None
+
+    # Get the themes for the first person in the people set
+    first_person_themes = themes_by_person.get(next(iter(people)), set())
+    # Initialize common_topics with the themes of the first person
+    common_topics = set(first_person_themes)
+
+    # Iterate through the remaining people, updating common_topics with the intersection of their themes
+    for person in people:
+        person_themes = themes_by_person.get(person, set())
+        common_topics.intersection_update(person_themes)
+
+    if not common_topics:
+        print("There are no overlapping themes among the given group.")
+        return None
+
+    return common_topics
+
+def CreatePersonToThemeMapping():
+    global themes, people_by_theme
+    people_by_theme = {}    
+
+    # Iterate through the list of themes
+    for theme in themes:
+        person = theme['person']
+        postId = theme['postId']
+        theme_info = (theme['theme'], postId)
+
+        # Check if the person already exists in the dictionary
+        if person not in people_by_theme:
+            people_by_theme[person] = set()
+        people_by_theme[person].add(theme_info)
+
+def CreateThemeToPersonMapping():
+    global people_by_theme, themes_by_person
+    themes_by_person = {}
+    print("Createthemetopersonmapping")
+    # Iterate through the dictionary to create themes with unique people
+    for person, person_themes in people_by_theme.items():
+        for theme_info in person_themes:
+            theme, _ = theme_info
+            if theme not in themes_by_person:
+                themes_by_person[theme] = set()
+            themes_by_person[theme].add(person)
+
+def GetEnjoymentIndex(choice):
+    # Extract the enjoyment index from the choice
+    print("choice", choice)
+    try:
+        choice_data = choice.get("metadata", {}).get("completion", {})
+        enjoyment_index = choice_data.get("Enjoyment index")
+        return float(enjoyment_index) if enjoyment_index else 0.0
+    except (ValueError, TypeError):
+        print("Failed to extract enjoyment index.")
+        return 0.0
+    
+def GenerateGameIdeas(themes_by_theme):
+    print("GenerateGameIdeas, themes_by_theme:", themes_by_theme)
+    # Filter themes with more than two people sharing it
+    eligible_themes = {theme: people for theme, people in themes_by_theme.items() if len(people) > 2}
+    print('\n****eligible themes')
+    for theme,people in eligible_themes.items():
+        print(f"Theme: {theme}")
+        print("People:", people)
+
+    # Check if there are eligible themes
+    if not eligible_themes:
+        print("No theme found with more than two people sharing it.")
+        return None
+
+    # Select a random eligible theme
+    chosen_theme = random.choice(list(eligible_themes.keys()))
+    print ("chosen_theme",chosen_theme)
+    # Prepare the prompt for GenAI
+    prompt = f"Provide your top 1 ideas for a text-based game this group should play based on their theme '{chosen_theme}'. For each idea, games should be fully playable via text using chat interface. Provide a rationale of why you chose that game, an enjoyment index (probability guess that the entire group will enjoy playing). Keep your answers fairly short. Answer in JSON, like this: {{\"Game name\": \"Description of game\", \"Enjoyment index\": Your guess as a probability from 0.0 to 1.0, \"Rationale\": \"Reasoning for game selection\"}}"    
+    # Make the GenAI request
+    response = openai.Completion.create(
+        engine="text-davinci-003",
+        prompt=prompt,
+        max_tokens=300,
+        n=1,
+        stop=None,
+        temperature=0.3,
+        top_p=1.0,
+        frequency_penalty=0.0,
+        presence_penalty=0.0
+    )
+     # Process the response and extract the game ideas
+    game_ideas = []
+    for choice in response.choices:
+        try:
+            game_data = json.loads(choice.text)
+            game_ideas.append(game_data)
+        except (json.JSONDecodeError, AttributeError):
+            print(f"Failed to decode game data: {choice.text}")
+
+    # Sort the game ideas by enjoyment index in descending order
+    sorted_game_ideas = sorted(game_ideas, key=lambda x: x.get("Enjoyment index", 0.0), reverse=True)
+    
+    if sorted_game_ideas:
+        with open(OUTPUT_GAME_IDEAS_DATAPATH, 'w') as file:
+            json.dump(sorted_game_ideas, file, indent=4)
+        return sorted_game_ideas
+    else:
+        print("No game idea found.")
+        return None
+
+
+def CreateGames():
+    global themes
+    ReadThemesFromFile()
+    group=CreateRandomGroup(3)
+    print("group", group)
+    common_topics = FindOverlappingTopics(group)
+    print("common topics: ", common_topics) 
+
+    PopulatePeopleByThemes()
+    CreatePersonToThemeMapping()
+    PrintPeopleByThemes() 
+
+    PopulateThemesByPerson()
+    CreateThemeToPersonMapping()     
+    PrintThemesByPerson()
+
+    game_ideas = GenerateGameIdeas(people_by_theme)
+    # Print the generated game ideas
+    if game_ideas:
+        print("Generated Game Idea:")
+        print(game_ideas)
+        return pd.DataFrame(game_ideas)
+    return None

create_games/data/game_ideas.json

@@ -0,0 +1,7 @@
+[
+    {
+        "Game name": "Ahmad Shareef's Adventure",
+        "Enjoyment index": 0.8,
+        "Rationale": "This game allows the group to explore a world based on Ahmad Shareef's life and adventures. Players can explore the world, solve puzzles, and battle enemies as they progress through the game. The game provides an engaging and interactive experience for the group, and allows them to explore a world based on Ahmad Shareef's life and adventures."
+    }
+]