Upload 2 files

app1.py

@@ -0,0 +1,472 @@
+import textwrap
+import gradio as gr
+
+
+def md(text: str) -> str:
+    """
+    Small formatting helper so long markdown strings stay readable in code.
+    """
+    return textwrap.dedent(text).strip()
+
+
+# ============================================================
+# GLOSSARY DATABASE
+# ------------------------------------------------------------
+# This app is intentionally simpler and less technical.
+# It assumes the learner may not know how repos, APIs,
+# containers, or ML engineering fit together.
+#
+# Each term has:
+# - a plain-English definition
+# - a business analogy
+# - a "what to learn first" section
+# ============================================================
+TERM_DB = {
+    "Software engineering": md("""
+    ## Software engineering
+
+    **Plain-English meaning:** Building software in a way that other people can understand, test, maintain, and improve.
+
+    **Business analogy:**
+    This is the difference between a one-off clever spreadsheet and a repeatable business process with documentation.
+
+    **What to learn first:**
+    - files and folders
+    - functions
+    - Git
+    - debugging
+    - testing mindset
+    """),
+
+    "API": md("""
+    ## API
+
+    **Plain-English meaning:** A clearly defined way for one system to ask another system to do something or send back data.
+
+    **Business analogy:**
+    Think of an API like a standard intake form between departments. The format matters.
+
+    **What to learn first:**
+    - request
+    - response
+    - JSON
+    - GET vs POST
+    """),
+
+    "Docker": md("""
+    ## Docker
+
+    **Plain-English meaning:** A way to package an app so it runs more consistently across environments.
+
+    **Business analogy:**
+    It is like shipping not just the recipe, but the kitchen setup too.
+
+    **What to learn first:**
+    - image vs container
+    - Dockerfile
+    - why environment drift is painful
+    """),
+
+    "CI/CD": md("""
+    ## CI/CD
+
+    **Plain-English meaning:** Automation that checks code and sometimes deploys it when changes are made.
+
+    **Business analogy:**
+    It is a quality gate plus release pipeline.
+
+    **What to learn first:**
+    - what happens on a code push
+    - what a workflow file is
+    - why automated checks reduce chaos
+    """),
+
+    "ML engineer": md("""
+    ## ML engineer
+
+    **Plain-English meaning:** The person who helps make machine learning useful in a real product or workflow.
+
+    **Business analogy:**
+    A data scientist proves value; an ML engineer makes that value repeatable and deployable.
+
+    **What to learn first:**
+    - data pipeline basics
+    - model inputs and outputs
+    - APIs
+    - deployment
+    - monitoring
+    """),
+
+    "MLOps": md("""
+    ## MLOps
+
+    **Plain-English meaning:** The operating discipline around training, shipping, observing, and updating ML systems.
+
+    **Business analogy:**
+    It is operations for machine learning, not just modeling.
+
+    **What to learn first:**
+    - experiment tracking
+    - versioning
+    - deployment
+    - monitoring
+    - iteration
+    """),
+
+    "Hugging Face Space": md("""
+    ## Hugging Face Space
+
+    **Plain-English meaning:** A hosted app repo where you can deploy Gradio, Docker, or static apps.
+
+    **Business analogy:**
+    Think of it as a lightweight demo showroom for AI apps.
+
+    **What to learn first:**
+    - README metadata block
+    - `app.py`
+    - commit and rebuild cycle
+    """)
+}
+
+
+COURSE_LIBRARY = md("""
+# Free and beginner-friendly references
+
+## Beginner coding
+- CS50 Python: https://cs50.harvard.edu/python
+
+## Modern AI / LLM learning
+- Hugging Face Learn: https://huggingface.co/learn
+- Hugging Face LLM Course: https://huggingface.co/learn/llm-course/chapter1/1
+
+## Building real AI products
+- Full Stack Deep Learning: https://fullstackdeeplearning.com/
+
+## Practical docs you eventually grow into
+- FastAPI: https://fastapi.tiangolo.com/
+- Docker Get Started: https://docs.docker.com/get-started/
+- GitHub Actions: https://docs.github.com/actions
+- Model Context Protocol: https://modelcontextprotocol.io/
+""")
+
+
+DEPLOY_GUIDE = md("""
+# How to deploy this beginner app to a Gradio Space
+
+1. Create a new Hugging Face Space.
+2. Choose **Gradio**.
+3. Replace the repo's `README.md` with a metadata block that includes `sdk: gradio` and `app_file: app.py` or `app_file: app1.py`.
+4. Paste this `app1.py` file.
+5. Add the `requirements_app1.txt` file provided with this package.
+6. Commit the changes.
+7. Open the Space and click through the tabs.
+
+This app uses only Gradio and the Python standard library, so the dependency file stays very small.
+""")
+
+
+def explain_term(term: str) -> str:
+    return TERM_DB.get(term, "Select a term.")
+
+
+def classify_project(problem_type, data_readiness, risk_level, time_horizon, technical_help):
+    if problem_type == "Summarize, extract, search, or chat with documents":
+        approach = "Start with an LLM workflow or retrieval-style app"
+        first_build = "A narrow document assistant with 10-20 realistic examples"
+        warning = "Do not promise full automation before you test edge cases and hallucination risks."
+
+    elif problem_type == "Predict a numeric value or class label":
+        approach = "Start with a supervised ML prototype"
+        first_build = "A baseline model with a clear label, clean sample data, and one metric"
+        warning = "Do not jump to deep learning before you prove a simple baseline is useful."
+
+    elif problem_type == "Automate repetitive form-like business decisions":
+        approach = "Start with rules-based automation first"
+        first_build = "A decision rules prototype with explicit inputs and outputs"
+        warning = "Many business workflows look like AI problems but are solved faster with rules first."
+
+    else:
+        approach = "Start with process mapping, then add AI where it clearly helps"
+        first_build = "A scoped proof of concept tied to one business action"
+        warning = "Avoid vague 'AI platform' projects with no narrow first use case."
+
+    data_note = {
+        "No clean data yet": "You likely need data cleanup, examples, or manual labeling before serious modeling.",
+        "Some spreadsheets / exports": "That is enough for a first prototype if the fields are understandable.",
+        "Clean structured data": "You are in strong shape for a simple prototype.",
+    }[data_readiness]
+
+    risk_note = {
+        "Low": "You can move quickly with demos and user feedback.",
+        "Medium": "Build review points and basic testing into the process.",
+        "High / regulated": "Bias toward traceability, validation, auditability, and human review.",
+    }[risk_level]
+
+    time_note = {
+        "2 weeks": "Scope down to a clickable demo, not a full production product.",
+        "1 month": "Aim for a working prototype with a few realistic examples and basic error handling.",
+        "2+ months": "You can include better structure, documentation, and deployment discipline.",
+    }[time_horizon]
+
+    help_note = {
+        "Mostly solo": "Prefer Gradio, simple Python, and small datasets.",
+        "One technical partner": "Good moment to split front-end demo and backend logic responsibilities.",
+        "Access to engineers": "Use this app to understand terminology so you can coordinate more effectively.",
+    }[technical_help]
+
+    return md(f"""
+    ## Recommended project shape
+
+    **Recommended approach:** {approach}
+
+    **First build:** {first_build}
+
+    **Data note:** {data_note}
+
+    **Risk note:** {risk_note}
+
+    **Timeline note:** {time_note}
+
+    **Team note:** {help_note}
+
+    **Important caution:** {warning}
+
+    ## First three actions
+    1. Write down the exact business decision this tool should improve.
+    2. Gather 10-20 realistic examples.
+    3. Define what a successful output looks like before adding complexity.
+    """)
+
+
+CODE_WALKTHROUGH = md("""
+# How to read an app like this
+
+## 1) Imports
+```python
+import textwrap
+import gradio as gr
+```
+- `textwrap` helps format long strings neatly.
+- `gradio` is the UI framework.
+
+## 2) Knowledge dictionaries
+This app stores explanations in Python dictionaries.
+That means the interface can look up a term and show the matching explanation.
+
+## 3) Functions
+Each button in a Gradio app usually calls a Python function.
+
+Example pattern:
+```python
+button.click(fn=my_function, inputs=[component_a], outputs=[component_b])
+```
+
+That line means:
+- when the button is pressed,
+- run `my_function` using the input component values,
+- then display the result in the output component.
+
+## 4) Layout
+`with gr.Blocks()` creates the app.
+Tabs, rows, buttons, radios, and text boxes are created inside it.
+
+## 5) Launch
+```python
+demo.launch()
+```
+This starts the app.
+On Hugging Face Spaces, the platform builds the repo and runs the app for you.
+
+## 6) What to change first
+- add one new glossary term
+- modify one recommendation rule
+- rename one UI label
+- add one new tab
+
+That is enough to start feeling ownership over the code.
+""")
+
+
+def make_30_day_plan(hours_per_week, confidence_level):
+    if confidence_level == "Very new":
+        week1 = "Learn variables, functions, conditionals, and loops with CS50 Python."
+        week2 = "Read simple Python scripts and change tiny pieces without fear."
+        week3 = "Learn what an API is, then run one Gradio app locally or in a notebook."
+        week4 = "Deploy one simple Space and practice explaining it in business language."
+
+    elif confidence_level == "Some exposure":
+        week1 = "Refresh Python basics and file structure."
+        week2 = "Learn APIs, requests, and Gradio events."
+        week3 = "Study FastAPI, Docker, and deployment vocabulary at a high level."
+        week4 = "Deploy one Space and write down the architecture in plain English."
+
+    else:
+        week1 = "Review Python, Git, and basic app structure."
+        week2 = "Learn APIs and small service design."
+        week3 = "Understand deployment tools: Docker, CI/CD, hosting."
+        week4 = "Compare LLM apps, ML apps, and rules engines using one business case."
+
+    pacing = (
+        "With this time budget, keep the goal to understanding and one tiny deployment each week."
+        if hours_per_week <= 4
+        else "With this time budget, you can both study and make small edits confidently each week."
+    )
+
+    return md(f"""
+    ## 30-day plan
+
+    **Weekly time budget:** {hours_per_week} hours
+
+    **Pacing note:** {pacing}
+
+    ### Week 1
+    {week1}
+
+    ### Week 2
+    {week2}
+
+    ### Week 3
+    {week3}
+
+    ### Week 4
+    {week4}
+
+    ## Recommended free sequence
+    1. CS50 Python
+    2. Hugging Face Learn or LLM Course
+    3. One Gradio Space deployment
+    4. Full Stack Deep Learning after the basics feel less intimidating
+    5. FastAPI and Docker docs when you want to move from demos to services
+    """)
+
+
+def route_decision(problem_statement: str):
+    text = problem_statement.lower()
+
+    if any(word in text for word in ["summarize", "extract", "search", "document", "email", "chat"]):
+        bucket = "LLM / language workflow"
+        why = "The problem sounds text-heavy and interaction-focused."
+
+    elif any(word in text for word in ["predict", "forecast", "classify", "score", "churn", "fraud"]):
+        bucket = "Classical ML / predictive modeling"
+        why = "The problem sounds like it needs a structured prediction target."
+
+    elif any(word in text for word in ["approve", "route", "if", "then", "policy", "quote", "form"]):
+        bucket = "Rules engine or workflow automation first"
+        why = "The problem sounds structured and may not need ML in the first version."
+
+    else:
+        bucket = "Needs process mapping first"
+        why = "The problem statement is still broad or ambiguous."
+
+    return md(f"""
+    ## First-pass route
+
+    **Best first bucket:** {bucket}
+
+    **Reason:** {why}
+
+    ## How to use this output
+    This is not a final architecture. It is a fast way to stop calling everything 'AI' and instead start by matching the problem to a build style.
+    """)
+
+
+INTRO = md("""
+# Business-to-Technical AI On-Ramp
+
+This Space is for someone who works around AI, product, operations, or business strategy and wants to become much more technically fluent without starting from a math-heavy or engineering-heavy place.
+
+## What this app helps with
+- translating technical terms into plain English
+- deciding whether a problem needs rules, ML, or LLM tooling
+- creating a realistic 30-day upskilling plan
+- learning enough code structure to stop being intimidated by app repositories
+""")
+
+
+with gr.Blocks(title="Business-to-Technical AI On-Ramp") as demo:
+    gr.Markdown(INTRO)
+
+    with gr.Tab("Glossary"):
+        term = gr.Dropdown(list(TERM_DB.keys()), value="Software engineering", label="Pick a term")
+        term_btn = gr.Button("Explain this term")
+        term_out = gr.Markdown(value=explain_term("Software engineering"))
+        term_btn.click(explain_term, inputs=term, outputs=term_out)
+
+    with gr.Tab("Project Scoper"):
+        problem_type = gr.Radio(
+            [
+                "Summarize, extract, search, or chat with documents",
+                "Predict a numeric value or class label",
+                "Automate repetitive form-like business decisions",
+                "Still not sure",
+            ],
+            value="Still not sure",
+            label="What kind of business problem is it?",
+        )
+
+        data_readiness = gr.Radio(
+            ["No clean data yet", "Some spreadsheets / exports", "Clean structured data"],
+            value="Some spreadsheets / exports",
+            label="How ready is the data?",
+        )
+
+        risk_level = gr.Radio(
+            ["Low", "Medium", "High / regulated"],
+            value="Medium",
+            label="What is the risk level?",
+        )
+
+        time_horizon = gr.Radio(
+            ["2 weeks", "1 month", "2+ months"],
+            value="1 month",
+            label="What is the delivery horizon?",
+        )
+
+        technical_help = gr.Radio(
+            ["Mostly solo", "One technical partner", "Access to engineers"],
+            value="One technical partner",
+            label="What technical help exists?",
+        )
+
+        scoper_btn = gr.Button("Generate recommendation")
+        scoper_out = gr.Markdown()
+
+        scoper_btn.click(
+            classify_project,
+            inputs=[problem_type, data_readiness, risk_level, time_horizon, technical_help],
+            outputs=scoper_out,
+        )
+
+    with gr.Tab("30-Day Plan"):
+        hours = gr.Slider(2, 12, value=4, step=1, label="Hours per week available")
+        confidence = gr.Radio(
+            ["Very new", "Some exposure", "Comfortable but inconsistent"],
+            value="Very new",
+            label="Current confidence level",
+        )
+        plan_btn = gr.Button("Build my 30-day plan")
+        plan_out = gr.Markdown()
+        plan_btn.click(make_30_day_plan, inputs=[hours, confidence], outputs=plan_out)
+
+    with gr.Tab("Problem Router"):
+        statement = gr.Textbox(
+            lines=5,
+            label="Describe the business problem",
+            placeholder="Example: We want to automate quote generation for industrial ventilation jobs using past quote files and customer specs.",
+        )
+        route_btn = gr.Button("Route this problem")
+        route_out = gr.Markdown()
+        route_btn.click(route_decision, inputs=statement, outputs=route_out)
+
+    with gr.Tab("Read the Code"):
+        gr.Markdown(CODE_WALKTHROUGH)
+
+    with gr.Tab("Deploy This Space"):
+        gr.Markdown(DEPLOY_GUIDE)
+
+    with gr.Tab("Free References"):
+        gr.Markdown(COURSE_LIBRARY)
+
+
+demo.launch()

requirements_app1.txt

@@ -0,0 +1 @@
+gradio>=5.0