Choosing the Best Python Framework for Your Tabletop Game Companion App

Build an efficient feat and skill database with ease using Python

Key Takeaways

Streamlit offers rapid development with minimal frontend knowledge.
Anvil provides a full-stack Python solution with drag-and-drop UI capabilities.
Dash is ideal for complex data visualizations and highly interactive interfaces.

Introduction

Creating a web application to manage feats, skills, items, and creatures for your tabletop game can significantly enhance gameplay and organization. Choosing the right framework is crucial to ensure that your app is both functional and user-friendly. This guide explores the most suitable Python frameworks—Streamlit, Anvil, and Dash—to help you decide which best fits your needs. After selecting the framework, detailed instructions and a sample mockup will guide you through the development process.

Evaluating Python Frameworks for Your Web App

Streamlit

Streamlit is renowned for its ability to turn Python scripts into interactive web apps with minimal effort. It is particularly advantageous for developers who are proficient in Python but may not have extensive frontend development experience.

Advantages of Streamlit:

Ease of Use: Streamlit allows for rapid app development without needing deep knowledge of HTML, CSS, or JavaScript.
Built-in Widgets: It provides a variety of interactive components such as text inputs, buttons, sliders, and dropdowns.
Database Integration: Easily integrates with SQLite, PostgreSQL, or MySQL for managing your data.
Real-Time Updates: Streamlit apps automatically update and reload in real-time as you make changes to the code.

Considerations:

While Streamlit is excellent for data-driven applications, it may have limitations for highly complex user interfaces or extensive customization.
Deployment options are straightforward with services like Streamlit Cloud, but may require additional configuration for scalability.

Anvil

Anvil is a full-stack Python framework that enables you to build web applications entirely in Python, including client-side and server-side code. It features a drag-and-drop UI builder, making it accessible for those who prefer visual design over coding every component.

Advantages of Anvil:

Full-Stack Development: Anvil allows you to develop both the frontend and backend using Python, eliminating the need for HTML, CSS, or JavaScript.
Drag-and-Drop UI Builder: The visual designer simplifies the process of creating complex user interfaces.
Built-In Database: Anvil provides integrated database functionality, making data management seamless.
Easy Deployment: Deploying Anvil apps is straightforward, with built-in hosting options.

Considerations:

Customization beyond the provided components may require deeper knowledge of Anvil's capabilities.
The learning curve can be steeper for those unfamiliar with the platform's unique features compared to more traditional frameworks.

Dash

Dash is a framework built on Flask and React.js, designed primarily for building analytical web applications. It excels in creating complex, interactive dashboards and supports advanced data visualization tools.

Advantages of Dash:

Advanced Visualization: Dash integrates seamlessly with Plotly, offering extensive data visualization capabilities.
Interactivity: Highly interactive components allow for dynamic user experiences.
Customization: Supports complex layouts and detailed customization options, suitable for sophisticated applications.
Scalable: Built on Flask, Dash can handle scalable, production-grade applications.

Considerations:

Requires a better understanding of frontend technologies like React.js for extensive customizations.
Development can be more involved compared to Streamlit and Anvil, making it less ideal for rapid prototyping.

Recommendation: Streamlit for Rapid Development

Based on the need for a quick and easy-to-use frontend, seamless database integration, and two-way linking capabilities, Streamlit emerges as the most suitable framework. It strikes an excellent balance between ease of use and functionality, making it ideal for building a comprehensive companion app for your tabletop game.

Why Choose Streamlit?

Swift Development: Streamlit enables you to build and deploy apps rapidly without extensive frontend development.
User-Friendly Interface: Its built-in widgets facilitate creating an intuitive and interactive user interface.
Python-Centric: Leveraging your Python expertise, Streamlit allows you to handle both backend logic and frontend presentation seamlessly.
Community and Support: A robust community and comprehensive documentation make troubleshooting and feature expansion manageable.

Building Your Tabletop Game Companion App with Streamlit

Step 1: Installing Required Packages

Begin by installing Streamlit and other necessary Python packages. Open your terminal or command prompt and execute the following command:

pip install streamlit sqlite3 pandas

Step 2: Setting Up the Database

For data storage, SQLite is an excellent choice due to its lightweight nature and ease of integration. Follow these steps to set up your database:

a. Define the Database Schema

Create a file named initialize_db.py and add the following code to define your database schema:

import sqlite3

def initialize_db():
    conn = sqlite3.connect('game_data.db')
    c = conn.cursor()
    # Create tables
    c.execute('''CREATE TABLE IF NOT EXISTS skills (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        description TEXT
    )''')
    c.execute('''CREATE TABLE IF NOT EXISTS feats (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        description TEXT,
        required_skills TEXT
    )''')
    c.execute('''CREATE TABLE IF NOT EXISTS items (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        description TEXT
    )''')
    c.execute('''CREATE TABLE IF NOT EXISTS creatures (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        description TEXT,
        linked_items TEXT,
        linked_feats TEXT
    )''')
    conn.commit()
    conn.close()

if __name__ == "__main__":
    initialize_db()

Run the script to create the database:

python initialize_db.py

Step 3: Developing the Streamlit App

Create a file named app.py and add the following code to develop the frontend and backend of your application:

a. Import Libraries and Connect to the Database

import streamlit as st
import sqlite3
import pandas as pd

def get_db_connection():
    conn = sqlite3.connect("game_data.db")
    conn.row_factory = sqlite3.Row
    return conn

def fetch_table_data(table_name):
    conn = get_db_connection()
    df = pd.read_sql_query(f"SELECT * FROM {table_name}", conn)
    conn.close()
    return df

b. Define the App Layout

st.title("Tabletop Game Companion")

menu = st.sidebar.selectbox("Menu", ["Skills", "Feats", "Items", "Creatures"])

if menu == "Skills":
    st.header("Skills")
    skills_df = fetch_table_data("skills")
    st.dataframe(skills_df)
    
    st.subheader("Add New Skill")
    with st.form("add_skill_form"):
        name = st.text_input("Skill Name")
        description = st.text_area("Description")
        submitted = st.form_submit_button("Add Skill")
        if submitted and name:
            conn = get_db_connection()
            conn.execute("INSERT INTO skills (name, description) VALUES (?, ?)", (name, description))
            conn.commit()
            conn.close()
            st.success("New skill added!")
            st.experimental_rerun()

elif menu == "Feats":
    st.header("Feats")
    feats_df = fetch_table_data("feats")
    st.dataframe(feats_df)
    
    st.subheader("Add New Feat")
    with st.form("add_feat_form"):
        name = st.text_input("Feat Name")
        description = st.text_area("Description")
        required_skills = st.text_input("Required Skills (comma-separated IDs)")
        submitted = st.form_submit_button("Add Feat")
        if submitted and name:
            conn = get_db_connection()
            conn.execute("INSERT INTO feats (name, description, required_skills) VALUES (?, ?, ?)", 
                        (name, description, required_skills))
            conn.commit()
            conn.close()
            st.success("New feat added!")
            st.experimental_rerun()

elif menu == "Items":
    st.header("Items")
    items_df = fetch_table_data("items")
    st.dataframe(items_df)
    
    st.subheader("Add New Item")
    with st.form("add_item_form"):
        name = st.text_input("Item Name")
        description = st.text_area("Description")
        submitted = st.form_submit_button("Add Item")
        if submitted and name:
            conn = get_db_connection()
            conn.execute("INSERT INTO items (name, description) VALUES (?, ?)", (name, description))
            conn.commit()
            conn.close()
            st.success("New item added!")
            st.experimental_rerun()

elif menu == "Creatures":
    st.header("Creatures")
    creatures_df = fetch_table_data("creatures")
    st.dataframe(creatures_df)
    
    st.subheader("Add New Creature")
    with st.form("add_creature_form"):
        name = st.text_input("Creature Name")
        description = st.text_area("Description")
        linked_items = st.text_input("Linked Items (comma-separated IDs)")
        linked_feats = st.text_input("Linked Feats (comma-separated IDs)")
        submitted = st.form_submit_button("Add Creature")
        if submitted and name:
            conn = get_db_connection()
            conn.execute("""
                INSERT INTO creatures (name, description, linked_items, linked_feats) 
                VALUES (?, ?, ?, ?)""", 
                (name, description, linked_items, linked_feats))
            conn.commit()
            conn.close()
            st.success("New creature added!")
            st.experimental_rerun()

c. Implement Two-Way Linking

To establish relationships between different entities (e.g., linking feats to skills), you can enhance your forms to include selection widgets that reference other tables. Here's how to modify the 'Add New Feat' form to allow linking to existing skills:

elif menu == "Feats":
    st.header("Feats")
    feats_df = fetch_table_data("feats")
    st.dataframe(feats_df)
    
    st.subheader("Add New Feat")
    with st.form("add_feat_form"):
        name = st.text_input("Feat Name")
        description = st.text_area("Description")
        skills = fetch_table_data("skills")
        skill_options = skills['id'].tolist()
        selected_skills = st.multiselect("Select Required Skills", skill_options)
        required_skills = ",".join(map(str, selected_skills))
        submitted = st.form_submit_button("Add Feat")
        if submitted and name:
            conn = get_db_connection()
            conn.execute("INSERT INTO feats (name, description, required_skills) VALUES (?, ?, ?)", 
                        (name, description, required_skills))
            conn.commit()
            conn.close()
            st.success("New feat added!")
            st.experimental_rerun()

Step 4: Running the Streamlit App

To launch your web application, navigate to your project directory in the terminal and run:

streamlit run app.py

This command will start the Streamlit server, and you can access your app by navigating to http://localhost:8501 in your web browser.

Enhancing the App with Additional Features

To make your companion app more robust, consider implementing the following features:

a. Search Functionality

Add a search bar to allow users to quickly find specific skills, feats, items, or creatures.

st.sidebar.header("Search")
query = st.sidebar.text_input("Enter search term")
if query:
    if menu == "Skills":
        results = skills_df[skills_df['name'].str.contains(query, case=False)]
        st.dataframe(results)
    elif menu == "Feats":
        results = feats_df[feats_df['name'].str.contains(query, case=False)]
        st.dataframe(results)
    # Repeat for Items and Creatures

b. Data Visualization

Integrate charts and graphs to visualize the distribution of skills, feats, items, and creatures.

import matplotlib.pyplot as plt

if menu == "Skills":
    st.header("Skills Distribution")
    skill_counts = skills_df['name'].value_counts()
    fig, ax = plt.subplots()
    skill_counts.plot(kind='bar', ax=ax)
    st.pyplot(fig)

c. Export and Import Functionality

Allow users to export data to CSV files or import data from existing files for backup and transfer purposes.

if st.button("Export Data"):
    skills_df.to_csv('skills_export.csv', index=False)
    st.success("Skills exported successfully!")

uploaded_file = st.file_uploader("Import Skills", type=["csv"])
if uploaded_file is not None:
    new_skills = pd.read_csv(uploaded_file)
    conn = get_db_connection()
    new_skills.to_sql('skills', conn, if_exists='append', index=False)
    conn.close()
    st.success("Skills imported successfully!")

Conclusion

Building a feature-rich companion app for your tabletop game is entirely feasible with Python frameworks like Streamlit. Streamlit offers a balanced combination of ease of use, rapid development, and sufficient customization to meet your requirements. By following the detailed steps outlined above, you can create an efficient and user-friendly application to manage feats, skills, items, and creatures, enhancing your gameplay experience.

References

docs.streamlit.io

Streamlit Documentation

anvil.works

dash.plotly.com

sqlite.org

pandas.pydata.org

Last updated January 27, 2025