Update README.md

README.md

@@ -10,4 +10,193 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Explanation of Updates:
+Renamed the Graph Function and Title:
+
+Renamed the function create_heterogeneous_graph to create_knowledge_graph to match your request.
+Changed the display title from "Your Journey (Heterogeneous Graph)" to "Your Journey (Knowledge Graph)".
+Adjusted the function calls in the main application to reflect the new function name.
+Modified the Graph Structure in create_knowledge_graph:
+
+Situation Nodes:
+
+Each unique situation is represented by a single node.
+Created a node for each situation only once by checking if the situation node ID is already in node_ids.
+Attempt Nodes:
+
+For each action (attempt), created a child node under the corresponding situation node.
+The attempt node includes the action, outcome, conclusion, and stars reflecting the score.
+Edges:
+
+Created an edge from the situation node to each attempt node.
+This results in a tree structure under each situation node showing all attempts.
+python
+Copy code
+def create_knowledge_graph(history_df):
+    nodes = []
+    edges = []
+    node_ids = {}
+    for index, row in history_df.iterrows():
+        situation_node_id = f"situation_{row['situation_id']}"
+        action_node_id = f"action_{index}"
+
+        # Situation node
+        if situation_node_id not in node_ids:
+            situation_node = StreamlitFlowNode(
+                situation_node_id,
+                pos=(0, 0),
+                data={'content': f"{row['situation_emoji']} {row['situation_name']}"},
+                type='default',
+                shape='ellipse'
+            )
+            nodes.append(situation_node)
+            node_ids[situation_node_id] = situation_node_id
+
+        # Attempt node (action and outcome)
+        outcome_content = '✅ Success' if row['outcome'] else '❌ Failure'
+        stars = '⭐' * int(row['score'])
+        attempt_node = StreamlitFlowNode(
+            action_node_id,
+            pos=(0, 0),
+            data={'content': f"{row['action_emoji']} {row['action_name']} ({outcome_content})\n{row['conclusion']}\n{stars}"},
+            type='default',
+            shape='rectangle'
+        )
+        nodes.append(attempt_node)
+
+        # Edge from situation to attempt
+        edges.append(StreamlitFlowEdge(
+            id=f"edge_{situation_node_id}_{action_node_id}",
+            source=situation_node_id,
+            target=action_node_id,
+            animated=True
+        ))
+
+    return nodes, edges
+Updated the Markdown Preview in create_markdown_preview:
+
+Modified the markdown structure to group attempts under each unique situation, regardless of the attempt number.
+The output now matches the format you provided, showing multiple attempts per situation.
+python
+Copy code
+def create_markdown_preview(history_df):
+    markdown = "## 🌳 Journey Preview\n\n"
+    grouped = history_df.groupby(['situation_name'], sort=False)
+
+    for situation_name, group in grouped:
+        markdown += f"### {group.iloc[0]['situation_emoji']} **{situation_name}**\n"
+        for _, row in group.iterrows():
+            outcome_str = '✅ Success' if row['outcome'] else '❌ Failure'
+            stars = '⭐' * int(row['score'])
+            markdown += f"- Attempt {row['attempt']}: {row['action_emoji']} **{row['action_name']}**: {outcome_str} {stars}\n"
+            markdown += f"  - {row['conclusion']}\n"
+        markdown += "\n"
+    return markdown
+Ensured the Graph Reflects the Journey Preview:
+
+The graph now displays each unique situation once, with all attempts as child nodes.
+This results in multiple trees, one for each situation, matching the three trees in your example.
+Adjusted the Main Function to Reflect Changes:
+
+Updated the function calls to use create_knowledge_graph instead of create_heterogeneous_graph.
+Changed the display title accordingly.
+python
+Copy code
+# Integration point for both functions
+if not game_state['history_df'].empty:
+    # 📝 Display Markdown Preview
+    st.markdown(create_markdown_preview(game_state['history_df']))
+
+    # 🌳 Display Knowledge Journey Graph
+    st.markdown("## 🌳 Your Journey (Knowledge Graph)")
+    nodes, edges = create_knowledge_graph(game_state['history_df'])
+    try:
+        streamlit_flow('cat_rider_flow',
+                       nodes,
+                       edges,
+                       layout=TreeLayout(direction='down'),
+                       fit_view=True,
+                       height=600)
+    except Exception as e:
+        st.error(f"An error occurred while rendering the journey graph: {str(e)}")
+        st.markdown("Please try refreshing the page if the graph doesn't appear.")
+How It Now Works:
+Graph Structure:
+
+Each unique situation is a node in the graph.
+All attempts (actions taken) under a situation are child nodes connected to the situation node.
+Both failures and successes are displayed as child nodes.
+This creates a tree structure for each situation, reflecting the multiple attempts.
+Journey Preview:
+
+The markdown preview shows the situations, with attempts listed under each.
+Attempts include the action taken, outcome, score (stars), and conclusion.
+The format matches the example you provided.
+Multiple Trees:
+
+If the player encounters multiple unique situations, the graph will display multiple trees.
+Each tree represents a situation with its attempts.
+This provides a clear visual of the player's journey through different scenarios.
+Example Output:
+Assuming the player has the following history:
+
+The Great Feline Escape:
+
+Attempt 1: Negotiate – Failure
+Attempt 2: Sprint Away – Success
+The Royal Tournament:
+
+Attempt 1: Sprint Away – Success
+Attempt 2: Show Bravery – Failure
+Attempt 3: Negotiate – Success
+The Great Cheese Heist:
+
+Attempt 1: Develop a Strategy – Success
+The graph will have three situation nodes:
+
+The Great Feline Escape
+
+Child Nodes:
+Negotiate (Failure)
+Sprint Away (Success)
+The Royal Tournament
+
+Child Nodes:
+Sprint Away (Success)
+Show Bravery (Failure)
+Negotiate (Success)
+The Great Cheese Heist
+
+Child Nodes:
+Develop a Strategy (Success)
+Running the Updated Code:
+Ensure Required Libraries Are Installed:
+
+bash
+Copy code
+pip install streamlit pandas plotly streamlit-flow
+Save the Code:
+
+Save the updated code into a file, e.g., cat_rider_game.py.
+
+Run the Streamlit App:
+
+bash
+Copy code
+streamlit run cat_rider_game.py
+Play the Game:
+
+Choose your Cat Rider and Riding Gear.
+Engage in adventures and make decisions.
+View the updated Journey Preview and Knowledge Graph after each action.
+Save and download your game histories via the sidebar.
+Note:
+If you encounter any issues with the streamlit-flow library, ensure it is correctly installed and compatible with your environment.
+The code assumes that the StreamlitFlowNode and StreamlitFlowEdge classes accept the parameters as specified. If not, you may need to adjust the parameter names according to the library's documentation.
+Conclusion:
+This updated code reflects your requirements by:
+
+Changing the graph to "Knowledge Graph".
+Displaying each situation once in the graph, with attempts as child nodes.
+Matching the Journey Preview format you provided.
+Providing a clear visualization of the player's journey with multiple trees for unique situations.