Upload 7 files

app.py

@@ -0,0 +1,80 @@
+import streamlit as st
+from pi_shard import pi_shard, get_pi_digits
+from gpt_utils import analyze_chunk
+from pi_utils import random_pi_fact, generate_pi_graph
+from pi_vector_utils import get_embedding, pi_rotation, pi_modulated_similarity
+import fitz
+import docx
+
+st.set_page_config(page_title="Play with Pi", layout="wide")
+st.title("🎲 Play with Pi - π-Based Chunking Engine")
+
+st.sidebar.header("🔧 Controls")
+openai_key = st.sidebar.text_input("OpenAI API Key", type="password")
+uploaded_file = st.file_uploader("Upload a document", type=["txt", "pdf", "docx"])
+
+if uploaded_file:
+    # Handle uploaded file types
+    if uploaded_file.name.endswith(".txt"):
+        text = uploaded_file.read().decode("utf-8")
+    elif uploaded_file.name.endswith(".pdf"):
+        doc = fitz.open(stream=uploaded_file.read(), filetype="pdf")
+        text = " ".join([page.get_text() for page in doc])
+    elif uploaded_file.name.endswith(".docx"):
+        doc = docx.Document(uploaded_file)
+        text = "\n".join([para.text for para in doc.paragraphs])
+
+    st.subheader("📄 Original Document")
+    st.text_area("Document Preview", text[:1000] + "...", height=150)
+
+    # Create π-based chunks
+    chunks = pi_shard(text)
+    st.subheader(f"🔍 π-Shards (Total: {len(chunks)})")
+    selected = st.selectbox("Select Chunk", range(len(chunks)))
+    st.code(chunks[selected], language="markdown")
+
+    # GPT Analysis of Selected Chunk
+    if openai_key:
+        st.markdown("#### ✨ GPT Analysis")
+        if st.button("Analyze Selected Chunk"):
+            with st.spinner("Thinking like π..."):
+                result = analyze_chunk(chunks[selected], openai_key)
+                st.success("Done!")
+                st.markdown(result)
+
+    # Question Answering Section
+    st.markdown("#### 🤔 Ask a Question about the Document")
+    user_query = st.text_area("Enter your question:", "")
+
+    if openai_key and st.button("🚀 Submit"):
+        if user_query:
+            st.info("Generating embeddings and rotating using π...")
+            pi_digits = get_pi_digits(len(chunks))
+            query_vec = get_embedding(user_query, openai_key)
+
+            scores = []
+            for i, chunk in enumerate(chunks):
+                chunk_vec = get_embedding(chunk, openai_key)
+                rotated = pi_rotation(chunk_vec, pi_digits[i])
+                sim = pi_modulated_similarity(query_vec, rotated, pi_digits[i])
+                scores.append((i, sim))
+
+            scores.sort(key=lambda x: x[1], reverse=True)
+            top_index = scores[0][0]
+
+            st.success(f"✅ Best π-Chunk Match (Chunk #{top_index})")
+            st.code(chunks[top_index])
+
+            # Analyze matched chunk with GPT
+            st.markdown("#### 📚 GPT Response to Query")
+            with st.spinner("Analyzing the matched chunk..."):
+                answer = analyze_chunk(chunks[top_index], openai_key)
+                st.markdown(answer)
+
+# Sidebar - Pi facts and visualization
+st.sidebar.subheader("🎲 Pi Fact")
+st.sidebar.info(random_pi_fact())
+
+if st.sidebar.button("🌀 Show π-Graph"):
+    fig = generate_pi_graph()
+    st.pyplot(fig)

gpt_utils.py

@@ -0,0 +1,15 @@
+import openai
+
+def analyze_chunk(chunk, openai_key):
+    openai.api_key = "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"
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4-turbo",
+            messages=[
+                {"role": "system", "content": "Summarize and analyze the following chunk."},
+                {"role": "user", "content": chunk}
+            ]
+        )
+        return response['choices'][0]['message']['content']
+    except Exception as e:
+        return f"Error: {str(e)}"

pi_shard.py

@@ -0,0 +1,26 @@
+import re
+
+def clean_text(text):
+    return re.sub(r'\s+', ' ', text).strip()
+
+def get_pi_digits(n=100):
+    with open('assets/pi_digits.txt', 'r') as f:
+        digits = f.read().replace('.', '').replace('\n', '')
+    return [int(d) for d in digits[:n] if d.isdigit()]
+
+def pi_shard(text, max_chunks=50):
+    text = clean_text(text)
+    pi_digits = get_pi_digits()
+    chunks = []
+    index = 0
+    i = 0
+
+    while index < len(text) and len(chunks) < max_chunks:
+        length = pi_digits[i % len(pi_digits)] + 1
+        chunk = text[index:index + length * 50]
+        overlap = pi_digits[(i+1) % len(pi_digits)] * 5
+        chunks.append(chunk)
+        index += length * 50 - overlap
+        i += 1
+
+    return chunks

pi_utils.py

@@ -0,0 +1,23 @@
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+
+pi_facts = [
+    "π is irrational and never ends!",
+    "π has been calculated to over 62 trillion digits!",
+    "The symbol π was first used in 1706.",
+    "You can’t express π as a fraction!",
+    "March 14 (3/14) is Pi Day!"
+]
+
+def random_pi_fact():
+    return random.choice(pi_facts)
+
+def generate_pi_graph():
+    digits = [int(d) for d in open('assets/pi_digits.txt').read() if d.isdigit()]
+    x = list(range(len(digits)))
+    y = np.cumsum([(-1)**i * d for i, d in enumerate(digits[:500])])
+    fig, ax = plt.subplots()
+    ax.plot(x[:len(y)], y)
+    ax.set_title("π Waveform based on Digits")
+    return fig

pi_vector_utils.py

@@ -0,0 +1,21 @@
+import numpy as np
+from numpy.linalg import norm
+import openai
+
+def get_embedding(text, openai_key):
+    openai.api_key = openai_key
+    try:
+        result = openai.Embedding.create(model="text-embedding-ada-002", input=text)
+        return np.array(result['data'][0]['embedding'])
+    except Exception as e:
+        return np.zeros(1536)  # Return zero vector on error
+
+def pi_rotation(embedding, pi_digit):
+    theta = (pi_digit / 9) * np.pi
+    rotated = embedding * np.cos(theta) + np.roll(embedding, 1) * np.sin(theta)
+    return rotated
+
+def pi_modulated_similarity(query_vec, chunk_vec, pi_digit):
+    cosine_sim = np.dot(query_vec, chunk_vec) / (norm(query_vec) * norm(chunk_vec))
+    weight = 1 + (pi_digit % 5) * 0.1
+    return cosine_sim * weight

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+openai==0.28
+python-docx
+PyMuPDF
+matplotlib
+numpy

style.css

@@ -0,0 +1,6 @@
+body {
+    background-color: #f0fff0;
+}
+h1, h2 {
+    color: #0a0;
+}