app.py

import streamlit as st
from time import sleep
import threading

# Thread-safe hash table class
class ThreadSafeHashTable:
    def __init__(self, size=10):
        self.size = size
        self.table = [[] for _ in range(size)]
        self.locks = [threading.Lock() for _ in range(size)]
    
    def _hash(self, key):
        return hash(key) % self.size
    
    def put(self, key, value):
        index = self._hash(key)
        with self.locks[index]:  # Thread-safe lock
            for i, (k, v) in enumerate(self.table[index]):
                if k == key:
                    self.table[index][i] = (key, value)
                    return
            self.table[index].append((key, value))
    
    def get(self, key):
        index = self._hash(key)
        with self.locks[index]:
            for k, v in self.table[index]:
                if k == key:
                    return v
        return None

    def delete(self, key):
        index = self._hash(key)
        with self.locks[index]:
            for i, (k, _) in enumerate(self.table[index]):
                if k == key:
                    del self.table[index][i]
                    return True
        return False

# Initialize the hash table
hash_table = ThreadSafeHashTable(size=10)

# Streamlit app
st.title("Thread-Safe Hash Table Visualization")

# Sidebar for inputs
st.sidebar.header("Operations")
key = st.sidebar.text_input("Key")
value = st.sidebar.text_input("Value")
operation = st.sidebar.selectbox("Operation", ["Put", "Get", "Delete"])
threads = st.sidebar.slider("Number of Threads", 1, 10, 1)

# Main area
st.header("Hash Table State")
for i, bucket in enumerate(hash_table.table):
    st.write(f"Bucket {i}: {bucket}")

# Log area
log = st.empty()

# Perform operation
if st.sidebar.button("Execute"):
    def perform_operation():
        if operation == "Put":
            hash_table.put(key, value)
            log.write(f"Put key={key}, value={value}")
        elif operation == "Get":
            result = hash_table.get(key)
            log.write(f"Get key={key}, result={result}")
        elif operation == "Delete":
            result = hash_table.delete(key)
            log.write(f"Delete key={key}, success={result}")

    threads_list = []
    for _ in range(threads):
        t = threading.Thread(target=perform_operation)
        t.start()
        threads_list.append(t)

    for t in threads_list:
        t.join()

    st.experimental_rerun()