Replace default files with traffic rules Q&A application

.gitignore

@@ -0,0 +1,19 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+vector_store/
+data/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env
+EOF
+
+# PDF files
+data/traffic_rules.pdf
+src/data/traffic_rules.pdf
+*.pdf

Dockerfile

@@ -1,21 +0,0 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,20 +1,15 @@
----
-title: Bangladesh Traffic Rules
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
+# Bangladesh Traffic Rules Q&A
 
-# Welcome to Streamlit!
+This chatbot specializes in answering questions about Bangladesh traffic rules and regulations.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Features
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+- RAG-based retrieval from official documents
+- Caching for faster responses
+- Traffic-specific query detection
+
+## How to Use
+
+1. Ask a question about Bangladesh traffic rules
+2. The system will search for relevant information
+3. You'll receive an answer based on the traffic rules database

requirements.txt

@@ -1,3 +1,10 @@
-altair
-pandas
-streamlit
+langgraph
+langchain-community #for local ollama
+langchain-ollama
+langchain-core
+langchain-huggingface
+python-dotenv
+faiss-cpu
+pypdf
+streamlit
+sentence-transformers

src/app.py

@@ -0,0 +1,238 @@
+# Import necessary libraries
+import streamlit as st  # For creating the web interface
+from langgraph.graph import StateGraph, START, END  # For creating the agent workflow
+from langgraph.checkpoint.memory import MemorySaver  # For saving conversation state
+from langchain_core.messages import HumanMessage, AIMessage  # For message types
+from rag import build_vectorstore, load_vectorstore, get_context  # RAG functions
+from state import AgentState  # State definition for our agent
+
+# Build or load the vector store (only done once at startup)
+build_vectorstore()
+vectorstore = load_vectorstore()
+
+def retrieve_rules(state: AgentState) -> AgentState:
+    """Retrieve relevant traffic rules based on the user's question."""
+    question = state["messages"][-1].content
+    context = get_context(vectorstore, question, k=5)
+    state["retriever"] = context
+    return state
+
+def is_traffic_related(question: str) -> bool:
+    """Check if the user's question is related to traffic rules."""
+    traffic_keywords = [
+        'traffic', 'driving', 'vehicle', 'car', 'motorcycle', 'bike', 'road', 'speed', 
+        'license', 'licence', 'signal', 'parking', 'park', 'helmet', 'seatbelt', 'accident', 
+        'fine', 'penalty', 'police', 'highway', 'junction', 'crossing', 'lane', 'overtake', 
+        'bangladesh', 'dhaka', 'chittagong', 'sylhet', 'rajshahi', 'khulna', 'barisal',
+        'rangpur', 'mymensingh', 'traffic light', 'roundabout', 'u-turn', 'horn',
+        'designated', 'violation', 'rule', 'law', 'regulation', 'transport', 'motor',
+        'rickshaw', 'bus', 'truck', 'taxi', 'cng', 'auto', 'tempo'
+    ]
+    question_lower = question.lower()
+    return any(keyword in question_lower for keyword in traffic_keywords)
+
+def clean_text(text: str) -> str:
+    """Clean and normalize text formatting."""
+    # Remove excessive whitespace and normalize line breaks
+    import re
+    
+    # Replace multiple whitespace characters with single space
+    text = re.sub(r'\s+', ' ', text)
+    
+    # Remove extra newlines and normalize
+    text = re.sub(r'\n+', ' ', text)
+    
+    # Clean up bullet points and formatting
+    text = re.sub(r'●\s*', '• ', text)
+    
+    return text.strip()
+
+def generate_smart_answer(question: str, context: str) -> str:
+    """Generate answer by intelligently parsing the context."""
+    if not context:
+        return "I don't have specific information about this traffic rule in my database."
+    
+    # Clean the context first
+    context = clean_text(context)
+    context_lower = context.lower()
+    question_lower = question.lower()
+    
+    # Split context into sentences for better processing
+    sentences = []
+    for s in context.split('.'):
+        cleaned_sentence = clean_text(s)
+        if cleaned_sentence and len(cleaned_sentence) > 10:  # Only keep meaningful sentences
+            sentences.append(cleaned_sentence)
+    
+    relevant_sentences = []
+    
+    # Look for penalty/fine information
+    if any(word in question_lower for word in ['penalty', 'fine', 'punishment']):
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in ['penalty', 'fine', 'tk ', 'taka', 'punishment', 'fee', 'charge', 'jail', 'prison']):
+                relevant_sentences.append(sentence)
+    
+    # Look for speed-related information
+    elif any(word in question_lower for word in ['speed', 'limit', 'fast', 'overspeeding']):
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in ['speed', 'limit', 'kmph', 'km/h', 'velocity', 'overtake', 'overspeed']):
+                relevant_sentences.append(sentence)
+    
+    # Look for parking-related information
+    elif any(word in question_lower for word in ['park', 'parking']):
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in ['park', 'parking', 'designated', 'stand', 'stopping']):
+                relevant_sentences.append(sentence)
+    
+    # Look for helmet-related information
+    elif 'helmet' in question_lower:
+        for sentence in sentences:
+            if 'helmet' in sentence.lower():
+                relevant_sentences.append(sentence)
+    
+    # Look for license-related information
+    elif any(word in question_lower for word in ['license', 'licence']):
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in ['license', 'licence', 'permit', 'driving']):
+                relevant_sentences.append(sentence)
+    
+    # General keyword matching
+    else:
+        question_words = question_lower.split()
+        for sentence in sentences:
+            sentence_lower = sentence.lower()
+            if any(word in sentence_lower for word in question_words if len(word) > 3):
+                relevant_sentences.append(sentence)
+    
+    # If we found relevant sentences, use them
+    if relevant_sentences:
+        # Take the most relevant sentences (max 3) and clean them
+        cleaned_sentences = []
+        for sentence in relevant_sentences[:3]:
+            cleaned = clean_text(sentence)
+            if cleaned:
+                cleaned_sentences.append(cleaned)
+        
+        if cleaned_sentences:
+            answer_text = '. '.join(cleaned_sentences)
+            return f"**Based on Bangladesh traffic rules:**\n\n{answer_text}."
+    
+    # Fallback: return first few sentences of context
+    fallback_sentences = []
+    for sentence in sentences[:2]:
+        cleaned = clean_text(sentence)
+        if cleaned:
+            fallback_sentences.append(cleaned)
+    
+    if fallback_sentences:
+        return f"**Based on Bangladesh traffic rules:**\n\n{'. '.join(fallback_sentences)}."
+    else:
+        return "I found relevant information but couldn't format it properly. Please try rephrasing your question."
+
+def generate_answer(state: AgentState) -> AgentState:
+    """Generate an answer using context parsing instead of LLM."""
+    question = state['messages'][-1].content
+    context = state['retriever'].strip()
+    
+    # Show debug information
+    st.write(f"🔍 Debug - Is traffic related: {is_traffic_related(question)}")
+    st.write(f"🔍 Debug - Context found: {len(context) > 0}")
+    st.write(f"🔍 Debug - Context length: {len(context)}")
+    
+    # Option to show the actual context being used
+    if context and st.checkbox("Show retrieved context (for debugging)", key="debug_context"):
+        st.text_area("Retrieved Context:", context, height=200)
+    
+    if is_traffic_related(question):
+        if context:
+            # Use our smart parsing instead of LLM
+            answer = generate_smart_answer(question, context)
+            st.write("✅ Using context-based answer generation")
+        else:
+            answer = "I don't have specific information about this particular traffic rule in my Bangladesh traffic rules database. For accurate and up-to-date information, I recommend checking with local traffic police or the Bangladesh Road Transport Authority (BRTA)."
+    else:
+        answer = """I specialize in answering questions about Bangladesh traffic rules and regulations. Your question seems to be about something else. 
+
+If you have any questions about traffic laws, driving regulations, parking rules, vehicle licensing, or traffic penalties in Bangladesh, I'd be happy to help!"""
+    
+    state["answer"] = answer
+    state["messages"].append(AIMessage(content=answer))
+    return state
+
+# Create the workflow
+workflow = StateGraph(AgentState)
+workflow.add_node("retrieve", retrieve_rules)
+workflow.add_node("answer", generate_answer)
+workflow.add_edge(START, "retrieve")
+workflow.add_edge("retrieve", "answer")
+workflow.add_edge("answer", END)
+graph = workflow.compile(checkpointer=MemorySaver())
+
+# Streamlit UI
+st.title("🚦 Bangladesh Traffic Rules Q&A")
+st.markdown("Ask questions about traffic rules, parking regulations, penalties, and driving laws in Bangladesh.")
+
+if "state" not in st.session_state:
+    st.session_state.state = AgentState(messages=[], retriever="", answer="")
+
+with st.expander("📝 Example Questions"):
+    st.markdown("""
+    - What is the penalty for not parking in a designated place?
+    - What is the penalty for overspeeding?
+    - What are the helmet rules for motorcycle riders?
+    - What documents do I need to carry while driving?
+    - What is the fine for running a red light?
+    """)
+
+question = st.text_input("Ask a question about Bangladesh traffic rules:", 
+                        placeholder="e.g., What is the penalty for overspeeding?")
+
+if st.button("Submit") and question.strip():
+    with st.spinner("Searching traffic rules..."):
+        st.session_state.state["messages"].append(HumanMessage(content=question))
+        thread_config = {"configurable": {"thread_id": "traffic_qa"}}
+        result = graph.invoke(st.session_state.state, config=thread_config)
+        st.session_state.state = result
+        
+        st.markdown("### 📋 Answer")
+        st.markdown(result['answer'])
+
+# Show conversation history
+if st.session_state.state["messages"]:
+    st.markdown("---")
+    st.markdown("### 💬 Conversation History")
+    recent_messages = st.session_state.state["messages"][-10:]
+    
+    for i, msg in enumerate(recent_messages):
+        if isinstance(msg, HumanMessage):
+            st.markdown(f"**❓ You:** {msg.content}")
+        else:
+            st.markdown(f"**🤖 Assistant:** {msg.content}")
+        if i < len(recent_messages) - 1:
+            st.markdown("---")
+
+# Sidebar
+with st.sidebar:
+    st.markdown("### 📊 System Status")
+    from rag import query_cache
+    st.write(f"🔍 Cached queries: {len(query_cache)}")
+    st.write(f"💬 Total messages: {len(st.session_state.state['messages'])}")
+    
+    if st.button("Clear Cache"):
+        query_cache.clear()
+        st.success("Cache cleared!")
+    
+    if st.button("Clear Conversation"):
+        st.session_state.state = AgentState(messages=[], retriever="", answer="")
+        st.success("Conversation cleared!")
+    
+    st.markdown("---")
+    st.markdown("### ℹ️ About")
+    st.markdown("""
+    This version uses intelligent context parsing instead of LLM for more reliable responses.
+    
+    **Features:**
+    - RAG-based retrieval from official documents
+    - Smart context parsing for answers
+    - Traffic-specific query detection
+    """)

src/config.py

@@ -0,0 +1,37 @@
+# Import necessary libraries
+import os  # For interacting with the operating system
+from dotenv import load_dotenv  # For loading environment variables from a .env file
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configuration for the Hugging Face model
+# This specifies which model to use for generating answers
+HUGGINGFACE_MODEL = os.getenv("HUGGINGFACE_MODEL", "google/flan-t5-base")
+
+# Path to the traffic rules PDF document
+# This is the source document that contains all the traffic rules
+DATA_PATH = os.getenv("DATA_PATH", "./data/traffic_rules.pdf")
+
+# Path to the vector store file
+# This is where the processed and searchable version of the traffic rules is stored
+VECTOR_STORE_PATH = os.getenv("VECTOR_STORE_PATH", "./vector_store/index.faiss")
+
+# Hugging Face API token for accessing models
+# This is required to use Hugging Face's hosted models
+HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN", "")
+
+# Hugging Face embedding model - using a small but efficient model
+# This model is only 22MB in size but provides good performance for semantic search
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+
+# Text chunking configuration
+# These settings determine how the PDF document is broken into manageable pieces
+
+# CHUNK_SIZE: The maximum number of characters in each chunk
+# Larger chunks preserve more context but may be less precise
+CHUNK_SIZE = 800
+
+# CHUNK_OVERLAP: The number of characters that overlap between adjacent chunks
+# Overlap helps ensure that important information isn't split between chunks
+CHUNK_OVERLAP = 100

src/rag.py

@@ -0,0 +1,262 @@
+import os  # For file and directory operations
+import re  # For regular expressions (text processing)
+from langchain_community.document_loaders import PyPDFLoader  # For loading PDF documents
+from langchain_community.vectorstores import FAISS  # For creating and using vector stores
+from langchain_community.embeddings import HuggingFaceEmbeddings  # For creating text embeddings using Hugging Face
+from langchain.text_splitter import RecursiveCharacterTextSplitter  # For splitting text into chunks
+from huggingface_hub import hf_hub_download  # For downloading files from Hugging Face
+from config import DATA_PATH, VECTOR_STORE_PATH, CHUNK_SIZE, CHUNK_OVERLAP, EMBEDDING_MODEL  # Configuration settings
+
+# Simple cache for storing query results
+# This helps speed up responses for repeated questions
+query_cache = {}
+
+def build_vectorstore():
+    """
+    Build a vector store from the traffic rules PDF document.
+    
+    This function processes the PDF document by:
+    1. Downloading the PDF from Hugging Face Datasets
+    2. Loading the document
+    3. Splitting it into manageable chunks
+    4. Creating embeddings for each chunk using Hugging Face
+    5. Storing the embeddings in a vector store for efficient searching
+    
+    The vector store is saved to disk so it only needs to be built once.
+    """
+    # Check if the vector store already exists
+    if os.path.exists(VECTOR_STORE_PATH):
+        print("Vector store already exists.")
+        return
+        
+    print("Building vector store...")
+    
+    # Download the PDF from Hugging Face Datasets
+    # Replace "ikReza/traffic-rules-pdf" with your actual dataset ID
+    pdf_path = hf_hub_download(
+        repo_id="ikReza/traffic-rules-pdf",
+        filename="traffic_rules.pdf",
+        repo_type="dataset",
+        local_dir="./data"  # Download to the data directory
+    )
+    
+    # Load the PDF document
+    loader = PyPDFLoader(pdf_path)
+    docs = loader.load()
+
+    # Create a text splitter to break the document into chunks
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=CHUNK_SIZE,  # Maximum characters per chunk
+        chunk_overlap=CHUNK_OVERLAP,  # Characters that overlap between chunks
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]  # Hierarchy of separators to use
+    )
+    
+    # Split the document into chunks
+    split_docs = splitter.split_documents(docs)
+
+    # Create embeddings for the chunks using Hugging Face model
+    # Embeddings are numerical representations of text that capture semantic meaning
+    embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
+    
+    # Create a vector store from the document chunks and their embeddings
+    vectorstore = FAISS.from_documents(split_docs, embeddings)
+
+    # Save the vector store to disk
+    os.makedirs(os.path.dirname(VECTOR_STORE_PATH), exist_ok=True)
+    vectorstore.save_local(VECTOR_STORE_PATH)
+    
+    print(f"Vector store built with {len(split_docs)} chunks")
+
+def load_vectorstore():
+    """
+    Load the vector store from disk.
+    
+    This function loads the previously created vector store so it can be used
+    for searching relevant traffic rules based on user questions.
+    
+    Returns:
+        The loaded vector store
+    """
+    # Create embeddings object (same model used when building the vector store)
+    embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
+    
+    # Load the vector store from disk
+    return FAISS.load_local(VECTOR_STORE_PATH, embeddings, allow_dangerous_deserialization=True)
+
+def preprocess_query(query):
+    """
+    Enhance the user's query with synonyms and related terms.
+    
+    This function improves search results by adding related terms to the query,
+    increasing the chances of finding relevant traffic rules.
+    
+    Args:
+        query: The original user query
+        
+    Returns:
+        Enhanced query with additional related terms
+    """
+    # Convert query to lowercase for processing
+    query_lower = query.lower()
+    
+    # List of enhancements to add based on query content
+    enhancements = []
+    
+    # Add parking-related terms if the query mentions parking
+    if 'park' in query_lower or 'parking' in query_lower:
+        enhancements.extend(['parking', 'park', 'designated place', 'vehicle standing', 
+                           'section 47', 'section 90', 'picking up', 'dropping off'])
+    
+    # Add penalty-related terms if the query mentions penalties or fines
+    if 'penalty' in query_lower or 'fine' in query_lower:
+        enhancements.extend(['penalty', 'fine', 'punishment', 'fee', 'charge', 'taka',
+                           'demerit point', 'violating', 'violation', 'offence'])
+    
+    # Add helmet-related terms if the query mentions helmets
+    if 'helmet' in query_lower:
+        enhancements.extend(['helmet', 'protective gear', 'safety equipment'])
+    
+    # Add speed-related terms if the query mentions speed
+    if 'speed' in query_lower:
+        enhancements.extend(['speed limit', 'velocity', 'driving speed'])
+    
+    # Add license-related terms if the query mentions licenses
+    if 'license' in query_lower or 'licence' in query_lower:
+        enhancements.extend(['license', 'licence', 'driving permit', 'permit'])
+    
+    # Add section references if the query mentions designated places
+    if 'designated' in query_lower:
+        enhancements.extend(['designated place', 'section 47', 'section 90', 
+                           'motor vehicles', 'provisions'])
+    
+    # Combine the original query with the enhancements
+    enhanced_query = f"{query} {' '.join(enhancements)}"
+    return enhanced_query
+
+def get_context(vectorstore, query, k=5):
+    """
+    Retrieve relevant traffic rules based on the user's query.
+    
+    This function searches the vector store for traffic rules that match the query,
+    using caching to speed up repeated queries.
+    
+    Args:
+        vectorstore: The vector store to search in
+        query: The user's question
+        k: The number of relevant documents to retrieve
+        
+    Returns:
+        A string containing the relevant traffic rules, or an empty string if no relevant rules are found
+    """
+    # Create a cache key for this query
+    cache_key = f"{query}_{k}"
+    
+    # Check if we already have a cached result for this query
+    if cache_key in query_cache:
+        print("Using cached result")
+        return query_cache[cache_key]
+    
+    print(f"Searching for: {query}")
+    
+    # Enhance the query with related terms to improve search results
+    enhanced_query = preprocess_query(query)
+    print(f"Enhanced query: {enhanced_query}")
+    
+    try:
+        # Search the vector store for documents similar to the query
+        docs_with_scores = vectorstore.similarity_search_with_score(query, k=k)
+        
+        # Filter relevant results based on their similarity scores
+        # Lower scores indicate higher similarity
+        relevant_docs = []
+        for doc, score in docs_with_scores:
+            # Use a threshold to determine if a document is relevant enough
+            if score < 1.5:  # This threshold may need adjustment based on your data
+                relevant_docs.append(doc.page_content)
+                print(f"Including doc with score: {score}")
+            else:
+                print(f"Excluding doc with score: {score}")
+        
+        # Join the relevant documents into a single context string
+        if relevant_docs:
+            context = "\n\n---\n\n".join(relevant_docs)
+            print(f"Found {len(relevant_docs)} relevant documents")
+        else:
+            context = ""
+            print("No relevant documents found")
+        
+    except Exception as e:
+        # Handle any errors that might occur during the search
+        print(f"Error during search: {e}")
+        context = ""
+    
+    # Simple cache management - keep only the last 100 queries
+    if len(query_cache) > 100:
+        # Remove the oldest entries to make room for new ones
+        oldest_keys = list(query_cache.keys())[:20]
+        for key in oldest_keys:
+            del query_cache[key]
+    
+    # Cache the result for future use
+    query_cache[cache_key] = context
+    
+    return context
+
+def extract_key_terms(query):
+    """
+    Extract key terms from the query for better searching.
+    
+    This function removes common stop words from the query to focus on
+    the important terms that are likely to match traffic rules.
+    
+    Args:
+        query: The user's question
+        
+    Returns:
+        A list of key terms extracted from the query
+    """
+    # Set of common stop words to filter out
+    stop_words = {'what', 'is', 'the', 'how', 'where', 'when', 'why', 'do', 'does', 
+                  'can', 'could', 'should', 'would', 'will', 'are', 'am', 'was', 
+                  'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having',
+                  'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+                  'of', 'with', 'by', 'about', 'into', 'through', 'during',
+                  'before', 'after', 'above', 'below', 'up', 'down', 'out',
+                  'off', 'over', 'under', 'again', 'further', 'then', 'once'}
+    
+    # Extract words from the query using regular expressions
+    words = re.findall(r'\b\w+\b', query.lower())
+    
+    # Filter out stop words and very short words
+    key_terms = [word for word in words if word not in stop_words and len(word) > 2]
+    
+    return key_terms
+
+# Debug function to test search results (useful for development)
+def debug_search(vectorstore, query, k=5):
+    """
+    Debug function to test and analyze search results.
+    
+    This function is useful during development to understand how the search
+    is performing and to fine-tune parameters.
+    
+    Args:
+        vectorstore: The vector store to search in
+        query: The query to test
+        k: The number of results to return
+        
+    Returns:
+        The search results with their scores
+    """
+    print(f"\n=== DEBUG SEARCH FOR: '{query}' ===")
+    
+    # Perform the search and get results with scores
+    docs_with_scores = vectorstore.similarity_search_with_score(query, k=k)
+    
+    # Print each result with its score
+    for i, (doc, score) in enumerate(docs_with_scores):
+        print(f"\n--- Result {i+1} (Score: {score:.4f}) ---")
+        print(f"Content: {doc.page_content[:200]}...")  # Show first 200 characters
+        print(f"Metadata: {doc.metadata}")
+    
+    return docs_with_scores

src/state.py

@@ -0,0 +1,27 @@
+from typing import Annotated, TypedDict
+from langgraph.graph.message import add_messages  # reducer
+
+class AgentState(TypedDict):
+    """
+    Define the state of our traffic rules agent.
+    
+    This class defines the structure of the state that will be passed between
+    different nodes in our LangGraph workflow. It contains all the information
+    needed to process a user's question and generate an answer.
+    
+    Attributes:
+        messages: A list of conversation messages (both human and AI)
+        retriever: The retrieved traffic rules context
+        answer: The generated answer to the user's question
+    """
+    # The messages attribute stores the conversation history
+    # It's annotated with add_messages to handle appending new messages
+    messages: Annotated[list, add_messages]
+    
+    # The retriever attribute stores the traffic rules context retrieved from the vector store
+    # This is used as the source of information for generating answers
+    retriever: str
+    
+    # The answer attribute stores the final generated answer
+    # This is what will be displayed to the user
+    answer: str

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))