updates

app.py

@@ -1,76 +1,15 @@
 import gradio as gr
-import openai, os
-import PyPDF2
-from huggingface_hub import Repository
-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
+import openai
+from home_view import ui_home as home
 from utilities import api_keys
-import pkg_resources
-dotenv_version = pkg_resources.get_distribution("tiktoken").version
-print(f"tiktoken version: {dotenv_version}")
+from sketch import sketch
 
 openai.api_key = api_keys.APIKeys().get_key('OPENAI_API_KEY')
 eleven_api_key = api_keys.APIKeys().get_key('ELEVEN_LABS_API_KEY')
 voice_id = api_keys.APIKeys().get_key('VOICE_ID')
 
-def FetchSlackJSON():
-     result=FetchSlack()
-     print("slack fetch")
-     print (result)
-     return result
 
-def InitProcess():
-     result=ProcessSlack()
-     print("slack processed")
-     print (result)
-     return result
+combo=home.combo
+combo.launch()
 
-def FetchEmbeddings():
-     result = CreateEmbeddings()
-     print("fetch embeddings")
-     print(result)
-     return result
-
-def FetchGames():
-     result = CreateGames()
-     print("result")
-     print(result)
-     return result
-
-with gr.Blocks() as ui1:
-    with gr.Row():
-        b1 = gr.Button("Fetch Slack JSON")
-    with gr.Row():
-        with gr.Column(scale=1, min_width=600):
-            df1 =gr.Dataframe(type="pandas")
-    b1.click(FetchSlackJSON,outputs=df1)
-
-with gr.Blocks() as ui2:
-    with gr.Row():
-        b2 = gr.Button("Process & Tag Slack Data")
-    with gr.Row():
-        with gr.Column(scale=1, min_width=600):
-            df2 =gr.Dataframe(type="pandas")
-    b2.click(ProcessSlack,outputs=df2)
-
-with gr.Blocks() as ui3:
-    with gr.Row():
-        b3 = gr.Button("Create Embeddings")
-    with gr.Row():
-        with gr.Column(scale=1, min_width=600):
-            df3 =gr.Dataframe(type="pandas")
-    b3.click(FetchEmbeddings,outputs=df3)
-
-with gr.Blocks() as ui4:
-    with gr.Row():
-        b4 = gr.Button("Find Games")
-    with gr.Row():
-        with gr.Column(scale=1, min_width=600):
-            df4 =gr.Dataframe(type="pandas")
-    b4.click(FetchGames,outputs=df4)
-
-demo = gr.TabbedInterface([ui1,ui2,ui3,ui4], ("Fetch Slack", "Process & Tag", "Create Embeddings", "Find Games"))
-demo.launch()
+#ui_sketch.ui.launch()

create_games/create_games_slack.py

@@ -14,6 +14,7 @@ OUTPUT_GAME_IDEAS_DATAPATH="create_games/data/game_ideas.json"
 themes = []
 themes_by_person={}
 people_by_theme = {}
+players=[]
 
 def ReadThemesFromFile():
     global themes
@@ -23,8 +24,6 @@ def ReadThemesFromFile():
 
 def PopulateThemesByPerson():
     global themes, themes_by_person
-    print("*** themes:")
-    print (themes)
     themes_by_person = {}
     for theme in themes:
         person = theme['person']
@@ -35,14 +34,35 @@ def PopulateThemesByPerson():
 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
+        print("Person themes:", person_themes)  
         for theme in person_themes:
             print(f"Theme: {theme}")
 
+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 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):
+        group_size=len(people)
+    # Randomly select a group of people
+    random_group = random.sample(people, group_size)
+    return random_group
+
 def PopulatePeopleByThemes():
     global themes, people_by_theme
     people_by_theme = {}
@@ -54,24 +74,25 @@ def PopulatePeopleByThemes():
 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 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 FindOverlappingTopics(people):
     global themes_by_person
     if not people:
@@ -80,6 +101,7 @@ def FindOverlappingTopics(people):
 
     # 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)
 
@@ -94,39 +116,12 @@ def FindOverlappingTopics(people):
 
     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")
+        enjoyment_index = choice_data.get("EnjoymentIndex")
         return float(enjoyment_index) if enjoyment_index else 0.0
     except (ValueError, TypeError):
         print("Failed to extract enjoyment index.")
@@ -135,7 +130,7 @@ def GetEnjoymentIndex(choice):
 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}
+    eligible_themes = {theme: people for theme, people in themes_by_theme.items() if len(people) > 1}
     print('\n****eligible themes')
     for theme,people in eligible_themes.items():
         print(f"Theme: {theme}")
@@ -150,30 +145,34 @@ def GenerateGameIdeas(themes_by_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
+    prompt = f"""Provide your top idea for a text-based game a group of 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. Keep your answers short. Answer in JSON, like this: {{"Name":"Name of game","Description":"Game description & rules","EnjoymentIndex":"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,
+        max_tokens=800,
         n=1,
-        stop=None,
         temperature=0.3,
-        top_p=1.0,
-        frequency_penalty=0.0,
-        presence_penalty=0.0
+        top_p=.8
     )
      # Process the response and extract the game ideas
     game_ideas = []
-    for choice in response.choices:
+    for choice in response["choices"]:
+        print("choice")
+        print (choice)       
+        choiceText = choice["text"]
+        game_data = choiceText.strip('\n')
+        print("--after strip camge_data", game_data)
         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}")
-
+            game_data_dict = json.loads(game_data)
+            game_ideas.append(game_data_dict)
+            print("game_data", game_data_dict)  
+        except json.JSONDecodeError:
+            print("Error decoding JSON. Skipping this entry.")
+        '''         GenerateGameIdeas(themes_by_theme)'''          
+        continue
+              
     # 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)
+    sorted_game_ideas = sorted(game_ideas, key=lambda x: x.get("EnjoymentIndex", 0.0), reverse=True)
     
     if sorted_game_ideas:
         with open(OUTPUT_GAME_IDEAS_DATAPATH, 'w') as file:
@@ -181,16 +180,24 @@ def GenerateGameIdeas(themes_by_theme):
         return sorted_game_ideas
     else:
         print("No game idea found.")
-        return None
+        return None       
+   
 
-def CreateGames():
+def GetPlayers():
+    players = []  # Initialize an empty list
+    index = 0  # Initialize an index variable starting from 0
+    for theme in themes:  # Assuming themes is a list of dictionaries
+        person = theme['person']
+        if person not in [t[0] for t in players]:  # Check if the person is already in the list
+            players.append((person, index))  # Append a tuple (str, int)
+            index += 1  # Increment the index
+    print("players")
+    print(players)
+    return players
+
+def LoadThemes():
     global themes
     ReadThemesFromFile()
-    group=CreateRandomGroup(3)
-    print("group", group)
-    common_topics = FindOverlappingTopics(group)
-    print("common topics: ", common_topics) 
-
     PopulatePeopleByThemes()
     CreatePersonToThemeMapping()
     PrintPeopleByThemes() 
@@ -199,10 +206,24 @@ def CreateGames():
     CreateThemeToPersonMapping()     
     PrintThemesByPerson()
 
-    game_ideas = GenerateGameIdeas(people_by_theme)
-    # Print the generated game ideas
-    if game_ideas:
+def CreateGameForGroup(group):
+    print("\n\ngroup, ", group)
+    common_topics = FindOverlappingTopics(group)
+    print("common topics: ", common_topics) 
+    print("****")
+    print("people by theme: ", people_by_theme)
+    print("****")
+    print("themes by person: ", themes_by_person)
+    game_ideas = GenerateGameIdeas(themes_by_person)
+    print("game ideas: ")
+    print(game_ideas)
+    '''  if( game_ideas is None):
+        print("game_ideas is None, trying again")
+        CreateGameForGroup(players)'''
+
+    if len(game_ideas) >0:
         print("Generated Game Idea:")
         print(game_ideas)
-        return pd.DataFrame(game_ideas)
+        gameDF=pd.DataFrame(game_ideas)
+        return gameDF
     return None

create_games/data/game_ideas.json

@@ -1,7 +1,8 @@
 [
     {
-        "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."
+        "Name": "John's Adventure",
+        "Description": "John's Adventure is a text-based game in which the player takes on the role of John, a brave explorer. The goal of the game is to explore the world, discover new lands, and complete various quests. The player must use their wits and skills to overcome obstacles and progress through the game. The game features a variety of puzzles, enemies, and items to collect. The game also features an inventory system and a leveling system.",
+        "EnjoymentIndex": "0.8",
+        "Rationale": "John's Adventure is a classic text-based game that offers a great deal of exploration and puzzle-solving. It also features a variety of items to collect and enemies to defeat, which adds to the game's replayability. The inventory and leveling systems also add an extra layer of depth to the game, making it more enjoyable for players."
     }
 ]

home_view/app_theme.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+from typing import Iterable
+import gradio as gr
+from gradio.themes.soft import Soft
+from gradio.themes.utils import colors, fonts, sizes
+import time
+
+class SoftBlue(Soft):
+    def __init__(
+        self,
+        *,
+        primary_hue: colors.Color | str = colors.cyan,
+        secondary_hue: colors.Color | str = colors.indigo,
+        neutral_hue: colors.Color | str = colors.sky,
+        spacing_size: sizes.Size | str = sizes.spacing_md,
+        radius_size: sizes.Size | str = sizes.radius_md,
+        text_size: sizes.Size | str = sizes.text_lg,
+        font: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("Quicksand"),
+            "ui-sans-serif",
+            "sans-serif",
+        ),
+        font_mono: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+            "ui-monospace",
+            "monospace",
+        ),
+    ):
+        super().__init__(
+            primary_hue=primary_hue,
+            secondary_hue=secondary_hue,
+            neutral_hue=neutral_hue,
+            spacing_size=spacing_size,
+            radius_size=radius_size,
+            text_size=text_size,
+            font=font,
+            font_mono=font_mono,
+        )
+    # html font style accepts a string heading or body and returns the style for that element, should follow styles in class with exception that heading is +2 pts and bold
+    def html_font_style(self, element: str) -> str:
+        if element == "heading":
+            return f"font-family: {self.font_mono}; font-size: {self.text_sm}; font-weight: bold;"
+        elif element == "body":
+            return f"font-family: {self.font_mono}; font-size: {self.text_sm};"
+        elif element == "mono":
+            return f"font-family: {self.font_mono}; font-size: {self.text_sm};"
+        else:
+            raise ValueError(
+                f"Element must be one of 'heading', 'body', or 'mono', not {element}"
+            )
+       

home_view/ui_home.py

@@ -0,0 +1,85 @@
+import gradio as gr
+import pandas as pd
+from home_view.app_theme import SoftBlue
+from sketch import sketch as sk
+from slack_processing.slack_data_prep import FetchSlack, ProcessSlack, CreateEmbeddings
+from create_games.create_games_slack import LoadThemes,GetPlayers,CreateGameForGroup
+
+startDF=pd.DataFrame()
+slackDF=pd.DataFrame()
+embeddingsDF=pd.DataFrame()
+gamesDF=pd.DataFrame()
+playersValues=[]
+selected= []
+players=[]
+
+def Init():
+    global startDF, slackDF, embeddingsDF, gamesDF,players,playersValues
+    startDF=FetchSlack()
+    slackDF=ProcessSlack()
+    embeddingsDF=CreateEmbeddings()
+    gamesDF=LoadThemes()
+    playersValues=GetPlayers()
+    playersCB.choices = playersValues
+    
+def SetSelected(playersCB):
+    global playersValues,selected,players
+    selected=[]
+    for check in playersCB:
+        selected.append(check)     
+        for player_name, player_id in playersValues:
+            if player_id == check:
+                if player_name not in players:
+                    players.append(player_name)
+                break    
+
+def PlayGame():   
+    print("PlayGame:")
+    #ui.add_child(home)
+    return gr.update(visible=True)
+
+def Predict(sketch):
+    confidences = sk.Predict(sketch)
+    return confidences
+
+def CreateGame():
+    global players,gameTitle
+    game_ideas = CreateGameForGroup(players)
+    if not game_ideas.empty:
+        game_ideas_dict = game_ideas.to_dict('records')
+        return game_ideas, game_ideas_dict[0]['Description'],game_ideas_dict[0]['Name']
+    return None,"No game"
+
+df1 =gr.Dataframe(type="pandas", value=startDF)
+df2 =gr.Dataframe(type="pandas", value=slackDF)
+df3 =gr.Dataframe(type="pandas", value=embeddingsDF)
+df4 =gr.Dataframe(type="pandas", value=gamesDF)
+
+with gr.Blocks() as ui:
+    with gr.Row():
+        logo=gr.Image(value="home_view/art/buildPlay.svg", width=200, height=200, show_download_button=False, container=False) 
+    directions= gr.Label(value="Directions go here", show_label=False, container=False)      
+    with gr.Column(): 
+        playersCB = gr.CheckboxGroup ([], label="Players", info="Pick some players for the game!" )
+    createBtn = gr.Button(value="Create Game", variant="primary")
+    gameTitle=gr.Markdown("Game Title", container=False)
+    desc=gr.TextArea(info="Game Description", interactive=False, show_label=False, container=False,
+                     placeholder="Your game description will show here", lines=3)
+    playBtn = gr.Button(value="Let's Play", variant="primary")
+    with gr.Row(visible=False) as holder:        
+        sketch=gr.Image(image_mode="L", source="canvas", width=600, height =600, invert_colors=True, interactive=True,
+                         brush_radius=.5,type="numpy",label="Sketch", show_label=True, show_upload_button=False, show_download_button=False, 
+                         container=False, allow_draw=True,  allow_magnify=True, allow_color_picker=True) 
+        label=gr.Label()
+    sketch.change(Predict, inputs=[sketch], outputs=[label])
+
+
+with gr.Blocks() as dfs:
+    startBtn=gr.Button(value="BuildPlay", variant="primary")    
+    gr.TabbedInterface([df1,df2,df3,df4], ("Start", "Slack","Embeddings","Games"))
+    startBtn.click(Init, inputs=[], outputs=[df1, df2, df3, df4])
+    playersCB.change(SetSelected, inputs=[playersCB], outputs=[])
+    createBtn.click(CreateGame, inputs=[], outputs=[df4,desc,gameTitle])
+    playBtn.click(PlayGame, inputs=[], outputs=[holder])
+combo=gr.TabbedInterface([ui,dfs], ("BuildPlay", "DataFrames"),theme=SoftBlue())
+Init()

sketch/class_names.txt

@@ -0,0 +1,100 @@
+airplane
+alarm_clock
+anvil
+apple
+axe
+baseball
+baseball_bat
+basketball
+beard
+bed
+bench
+bicycle
+bird
+book
+bread
+bridge
+broom
+butterfly
+camera
+candle
+car
+cat
+ceiling_fan
+cell_phone
+chair
+circle
+clock
+cloud
+coffee_cup
+cookie
+cup
+diving_board
+donut
+door
+drums
+dumbbell
+envelope
+eye
+eyeglasses
+face
+fan
+flower
+frying_pan
+grapes
+hammer
+hat
+headphones
+helmet
+hot_dog
+ice_cream
+key
+knife
+ladder
+laptop
+light_bulb
+lightning
+line
+lollipop
+microphone
+moon
+mountain
+moustache
+mushroom
+pants
+paper_clip
+pencil
+pillow
+pizza
+power_outlet
+radio
+rainbow
+rifle
+saw
+scissors
+screwdriver
+shorts
+shovel
+smiley_face
+snake
+sock
+spider
+spoon
+square
+star
+stop_sign
+suitcase
+sun
+sword
+syringe
+t-shirt
+table
+tennis_racquet
+tent
+tooth
+traffic_light
+tree
+triangle
+umbrella
+wheel
+wristwatch

sketch/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:effb6ea6f1593c09e8247944028ed9c309b5ff1cef82ba38b822bee2ca4d0f3c
+size 1656903

sketch/sketch.py

@@ -0,0 +1,49 @@
+import torch
+from PIL import Image
+import numpy as np
+from torch import nn
+from pathlib import Path
+
+PATH="sketch/class_names.txt"
+LABELS = Path(PATH).read_text().splitlines()
+
+model = nn.Sequential(
+    nn.Conv2d(1, 32, 3, padding='same'),
+    nn.ReLU(),
+    nn.MaxPool2d(2),
+    nn.Conv2d(32, 64, 3, padding='same'),
+    nn.ReLU(),
+    nn.MaxPool2d(2),
+    nn.Conv2d(64, 128, 3, padding='same'),
+    nn.ReLU(),
+    nn.MaxPool2d(2),
+    nn.Flatten(),
+    nn.Linear(1152, 256),
+    nn.ReLU(),
+    nn.Linear(256, len(LABELS)),
+)
+state_dict = torch.load('sketch/pytorch_model.bin',    map_location='cpu')
+model.load_state_dict(state_dict, strict=False)
+model.eval()
+
+def Predict(img):
+    # Convert to grayscale if the image is RGB
+    if img is not None and img.any():
+        if img.shape[-1] == 3:
+            img = np.mean(img, axis=-1)
+    # Convert the NumPy array to a PIL image
+    img_pil = Image.fromarray(img.astype('uint8'))
+    # Resize the image
+    img_resized = img_pil.resize((28, 28), Image.ANTIALIAS) 
+    # Convert the PIL image back to a NumPy array
+    img_np = np.array(img_resized)
+    # Convert to tensor and normalize
+    x = torch.tensor(img_np, dtype=torch.float32).unsqueeze(0).unsqueeze(0) / 255.0
+    # Model prediction
+    with torch.no_grad():
+        out = model(x)
+    probabilities = torch.nn.functional.softmax(out[0], dim=0)
+    values, indices = torch.topk(probabilities, 5)
+    confidences = {LABELS[i]: v.item() for i, v in zip(indices, values)}
+    return confidences
+

ui_holder.py

@@ -0,0 +1,80 @@
+
+import gradio as gr
+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
+
+def InitDF():
+    global imageDF
+    imageDF=pd.DataFrame({"role": [""], "content": [""] })
+
+def UpdateArtSetting(setting):
+    global settingOptions
+    settingOptions.value=setting
+
+def UpdateArtStyle(art):
+    global artOptions
+    artOptions.value=art
+
+def Generate(imageDescription):
+    global artOptions, settingOptions
+    return image_generation.GenerateImages(imageDescription, artOptions, settingOptions)
+
+def FetchSlackJSON():
+     result=FetchSlack()
+     print("slack fetch")
+     print (result)
+     return result
+
+def InitProcess():
+     result=ProcessSlack()
+     print("slack processed")
+     print (result)
+     return result
+
+def FetchEmbeddings():
+     result = CreateEmbeddings()
+     print("fetch embeddings")
+     print(result)
+     return result
+
+def FetchGames():
+     result = CreateGames()
+     print("result")
+     print(result)
+     return result
+
+
+with gr.Blocks() as ui1:
+    with gr.Row():
+        b1 = gr.Button("Fetch Slack JSON")
+    with gr.Row():
+        with gr.Column(scale=1, min_width=600):
+            df1 =gr.Dataframe(type="pandas")
+    b1.click(FetchSlackJSON,outputs=df1)
+
+with gr.Blocks() as ui2:
+    with gr.Row():
+        b2 = gr.Button("Process & Tag Slack Data")
+    with gr.Row():
+        with gr.Column(scale=1, min_width=600):
+            df2 =gr.Dataframe(type="pandas")
+    b2.click(ProcessSlack,outputs=df2)
+
+with gr.Blocks() as ui3:
+    with gr.Row():
+        b3 = gr.Button("Create Embeddings")
+    with gr.Row():
+        with gr.Column(scale=1, min_width=600):
+            df3 =gr.Dataframe(type="pandas")
+    b3.click(FetchEmbeddings,outputs=df3)
+
+with gr.Blocks() as ui4:
+    with gr.Row():
+        b4 = gr.Button("Find Games")
+    with gr.Row():
+        with gr.Column(scale=1, min_width=600):
+            df4 =gr.Dataframe(type="pandas")
+    b4.click(FetchGames,outputs=df4)
+
+demo = gr.TabbedInterface([ui1,ui2,ui3,ui4], ("Fetch Slack", "Process & Tag", "Create Embeddings", "Find Games"))