merge~2

Author: shubhmrj

Flask Server part ~1/README.md

@@ -0,0 +1,40 @@
+# Python Project Hub
+
+A web platform where users can sign up, log in, view all your Python projects, read their descriptions and code, and run them in real time.
+
+## Features
+- User authentication (signup & login)
+- List Python projects with description and code
+- Run Python code in real time from the browser
+
+## Tech Stack
+- Frontend: React
+- Backend: FastAPI (Python)
+- Database: SQLite
+
+## Getting Started
+
+### Backend
+1. Navigate to `backend` and install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+2. Run the backend server:
+   ```bash
+   uvicorn main:app --reload
+   ```
+
+### Frontend
+1. Navigate to `frontend` and install dependencies:
+   ```bash
+   npm install
+   ```
+2. Run the frontend:
+   ```bash
+   npm start
+   ```
+
+---
+
+### Security Note
+Do NOT deploy this as-is for public use. Running arbitrary code is dangerous. Use containers, resource limits, and input validation for real deployments.

Flask Server part ~1/advanced_shape_gui_factory.py

@@ -0,0 +1,179 @@
+import tkinter as tk
+from tkinter import colorchooser
+from abc import ABC, abstractmethod
+
+# Shape interface
+class Shape(ABC):
+    @abstractmethod
+    def draw(self, canvas, **kwargs):
+        pass
+
+class Circle(Shape):
+    def draw(self, canvas, center, radius, fill, outline, width):
+        x0 = center[0] - radius
+        y0 = center[1] - radius
+        x1 = center[0] + radius
+        y1 = center[1] + radius
+        canvas.create_oval(x0, y0, x1, y1, fill=fill, outline=outline, width=width)
+
+class Square(Shape):
+    def draw(self, canvas, center, side, fill, outline, width):
+        half = side // 2
+        x0 = center[0] - half
+        y0 = center[1] - half
+        x1 = center[0] + half
+        y1 = center[1] + half
+        canvas.create_rectangle(x0, y0, x1, y1, fill=fill, outline=outline, width=width)
+
+class Rectangle(Shape):
+    def draw(self, canvas, center, width_r, height_r, fill, outline, width):
+        x0 = center[0] - width_r // 2
+        y0 = center[1] - height_r // 2
+        x1 = center[0] + width_r // 2
+        y1 = center[1] + height_r // 2
+        canvas.create_rectangle(x0, y0, x1, y1, fill=fill, outline=outline, width=width)
+
+class ShapeFactory:
+    @staticmethod
+    def create_shape(shape_type):
+        shape_type = shape_type.lower()
+        if shape_type == 'circle':
+            return Circle()
+        elif shape_type == 'square':
+            return Square()
+        elif shape_type == 'rectangle':
+            return Rectangle()
+        else:
+            raise ValueError(f"Unknown shape type: {shape_type}")
+
+class AdvancedShapeApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("Advanced Shape Factory GUI")
+        self.root.geometry("600x500")
+        self.root.resizable(False, False)
+        self.bg_color = "#f2f2f2"
+        self.selected_color = "#3498db"
+        self.outline_color = "#222"
+        self.outline_width = 3
+
+        # Controls Frame
+        self.controls = tk.Frame(root, bg="#e8eaf6", bd=2, relief=tk.GROOVE)
+        self.controls.place(x=10, y=10, width=220, height=480)
+
+        tk.Label(self.controls, text="Shape Type", bg="#e8eaf6", font=("Segoe UI", 11, "bold")).pack(pady=7)
+        self.shape_var = tk.StringVar(value="circle")
+        shapes = ["circle", "square", "rectangle"]
+        for s in shapes:
+            tk.Radiobutton(self.controls, text=s.title(), variable=self.shape_var, value=s, bg="#e8eaf6", font=("Segoe UI", 10)).pack(anchor=tk.W)
+
+        # Size controls (dynamic)
+        self.size_frame = tk.Frame(self.controls, bg="#e8eaf6")
+        self.size_frame.pack(pady=8)
+        self.size_labels = {}
+        self.size_entries = {}
+        self._create_size_controls()
+        self.shape_var.trace_add('write', lambda *args: self._update_size_controls())
+
+        # Color picker
+        tk.Label(self.controls, text="Fill Color", bg="#e8eaf6", font=("Segoe UI", 11, "bold")).pack(pady=(12, 3))
+        self.color_btn = tk.Button(self.controls, text="Choose Color", command=self.choose_color, bg=self.selected_color, fg="white", font=("Segoe UI", 10, "bold"))
+        self.color_btn.pack(pady=2)
+
+        # Outline width
+        tk.Label(self.controls, text="Outline Width", bg="#e8eaf6", font=("Segoe UI", 11, "bold")).pack(pady=(10, 3))
+        self.outline_entry = tk.Entry(self.controls, width=5, font=("Segoe UI", 10))
+        self.outline_entry.insert(0, str(self.outline_width))
+        self.outline_entry.pack(pady=2)
+
+        # Draw & Clear
+        self.draw_btn = tk.Button(self.controls, text="Draw Shape", command=self.draw_shape, bg="#43a047", fg="white", font=("Segoe UI", 11, "bold"))
+        self.draw_btn.pack(pady=(16, 5), fill=tk.X)
+        self.clear_btn = tk.Button(self.controls, text="Clear Canvas", command=self.clear_canvas, bg="#e53935", fg="white", font=("Segoe UI", 11, "bold"))
+        self.clear_btn.pack(pady=2, fill=tk.X)
+
+        # Canvas
+        self.canvas = tk.Canvas(root, width=340, height=460, bg=self.bg_color, highlightthickness=2, highlightbackground="#888")
+        self.canvas.place(x=250, y=15)
+
+        # Status
+        self.status_label = tk.Label(root, text="", fg="red", font=("Segoe UI", 10))
+        self.status_label.place(x=250, y=480)
+
+    def _create_size_controls(self):
+        # Remove old
+        for widget in self.size_frame.winfo_children():
+            widget.destroy()
+        self.size_labels.clear()
+        self.size_entries.clear()
+        # Create for default (circle)
+        self._update_size_controls()
+
+    def _update_size_controls(self):
+        for widget in self.size_frame.winfo_children():
+            widget.destroy()
+        shape = self.shape_var.get()
+        if shape == "circle":
+            self.size_labels['radius'] = tk.Label(self.size_frame, text="Radius:", bg="#e8eaf6", font=("Segoe UI", 10))
+            self.size_labels['radius'].grid(row=0, column=0, sticky=tk.W)
+            self.size_entries['radius'] = tk.Entry(self.size_frame, width=8, font=("Segoe UI", 10))
+            self.size_entries['radius'].insert(0, "60")
+            self.size_entries['radius'].grid(row=0, column=1)
+        elif shape == "square":
+            self.size_labels['side'] = tk.Label(self.size_frame, text="Side:", bg="#e8eaf6", font=("Segoe UI", 10))
+            self.size_labels['side'].grid(row=0, column=0, sticky=tk.W)
+            self.size_entries['side'] = tk.Entry(self.size_frame, width=8, font=("Segoe UI", 10))
+            self.size_entries['side'].insert(0, "100")
+            self.size_entries['side'].grid(row=0, column=1)
+        elif shape == "rectangle":
+            self.size_labels['width'] = tk.Label(self.size_frame, text="Width:", bg="#e8eaf6", font=("Segoe UI", 10))
+            self.size_labels['width'].grid(row=0, column=0, sticky=tk.W)
+            self.size_entries['width'] = tk.Entry(self.size_frame, width=8, font=("Segoe UI", 10))
+            self.size_entries['width'].insert(0, "150")
+            self.size_entries['width'].grid(row=0, column=1)
+            self.size_labels['height'] = tk.Label(self.size_frame, text="Height:", bg="#e8eaf6", font=("Segoe UI", 10))
+            self.size_labels['height'].grid(row=1, column=0, sticky=tk.W)
+            self.size_entries['height'] = tk.Entry(self.size_frame, width=8, font=("Segoe UI", 10))
+            self.size_entries['height'].insert(0, "80")
+            self.size_entries['height'].grid(row=1, column=1)
+
+    def choose_color(self):
+        color = colorchooser.askcolor(title="Choose Fill Color", initialcolor=self.selected_color)
+        if color[1]:
+            self.selected_color = color[1]
+            self.color_btn.config(bg=self.selected_color)
+
+    def draw_shape(self):
+        shape_type = self.shape_var.get()
+        try:
+            outline_width = int(self.outline_entry.get())
+        except Exception:
+            self.status_label.config(text="Outline width must be a number.", fg="red")
+            return
+        # Get size
+        try:
+            if shape_type == "circle":
+                radius = int(self.size_entries['radius'].get())
+                shape = ShapeFactory.create_shape(shape_type)
+                shape.draw(self.canvas, center=(170, 230), radius=radius, fill=self.selected_color, outline=self.outline_color, width=outline_width)
+            elif shape_type == "square":
+                side = int(self.size_entries['side'].get())
+                shape = ShapeFactory.create_shape(shape_type)
+                shape.draw(self.canvas, center=(170, 230), side=side, fill=self.selected_color, outline=self.outline_color, width=outline_width)
+            elif shape_type == "rectangle":
+                width_r = int(self.size_entries['width'].get())
+                height_r = int(self.size_entries['height'].get())
+                shape = ShapeFactory.create_shape(shape_type)
+                shape.draw(self.canvas, center=(170, 230), width_r=width_r, height_r=height_r, fill=self.selected_color, outline=self.outline_color, width=outline_width)
+            self.status_label.config(text=f"Drew a {shape_type}.", fg="green")
+        except Exception as e:
+            self.status_label.config(text=f"Error: {e}", fg="red")
+
+    def clear_canvas(self):
+        self.canvas.delete("all")
+        self.status_label.config(text="Canvas cleared.", fg="blue")
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = AdvancedShapeApp(root)
+    root.mainloop()

Flask Server part ~1/backend/auth.py

@@ -0,0 +1,52 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from sqlalchemy.orm import Session
+from .database import SessionLocal
+from .models import User
+
+SECRET_KEY = "YOUR_SECRET_KEY"
+ALGORITHM = "HS256"
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_user(db, username: str):
+    return db.query(User).filter(User.username == username).first()
+
+def authenticate_user(db, username: str, password: str):
+    user = get_user(db, username)
+    if not user or not verify_password(password, user.hashed_password):
+        return False
+    return user
+
+def create_access_token(data: dict):
+    from datetime import datetime, timedelta
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(hours=2)
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(SessionLocal)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = get_user(db, username=username)
+    if user is None:
+        raise credentials_exception
+    return user

Flask Server part ~1/backend/database.py

@@ -0,0 +1,7 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+DATABASE_URL = "sqlite:///./test.db"
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()

Flask Server part ~1/backend/main.py

@@ -0,0 +1,67 @@
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.orm import Session
+from . import models, database, auth
+from .models import User, Project
+import os
+import subprocess
+
+app = FastAPI()
+models.Base.metadata.create_all(bind=database.engine)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def get_db():
+    db = database.SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@app.post("/signup")
+def signup(username: str, password: str, db: Session = Depends(get_db)):
+    if db.query(User).filter(User.username == username).first():
+        raise HTTPException(status_code=400, detail="Username already registered")
+    user = User(username=username, hashed_password=auth.get_password_hash(password))
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return {"msg": "User created"}
+
+@app.post("/token")
+def login(username: str, password: str, db: Session = Depends(get_db)):
+    user = auth.authenticate_user(db, username, password)
+    if not user:
+        raise HTTPException(status_code=400, detail="Incorrect username or password")
+    token = auth.create_access_token({"sub": user.username})
+    return {"access_token": token, "token_type": "bearer"}
+
+@app.get("/projects")
+def list_projects(db: Session = Depends(get_db), user: User = Depends(auth.get_current_user)):
+    return db.query(Project).all()
+
+@app.get("/project/{project_id}")
+def get_project(project_id: int, db: Session = Depends(get_db), user: User = Depends(auth.get_current_user)):
+    project = db.query(Project).filter(Project.id == project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+    with open(f"backend/projects/{project.filename}", "r") as f:
+        code = f.read()
+    return {"name": project.name, "description": project.description, "code": code}
+
+@app.post("/run/{project_id}")
+def run_project(project_id: int, db: Session = Depends(get_db), user: User = Depends(auth.get_current_user)):
+    project = db.query(Project).filter(Project.id == project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+    try:
+        result = subprocess.run(["python", f"backend/projects/{project.filename}"], capture_output=True, text=True, timeout=10)
+        return {"stdout": result.stdout, "stderr": result.stderr}
+    except Exception as e:
+        return {"stdout": "", "stderr": str(e)}

Flask Server part ~1/backend/models.py

@@ -0,0 +1,15 @@
+from sqlalchemy import Column, Integer, String
+from .database import Base
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+
+class Project(Base):
+    __tablename__ = "projects"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, unique=True, index=True)
+    description = Column(String)
+    filename = Column(String)

Flask Server part ~1/backend/projects/.gitkeep

@@ -0,0 +1 @@
+

Flask Server part ~1/backend/requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+sqlalchemy
+passlib[bcrypt]
+python-jose
+pydantic

Flask Server part ~1/frontend/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "python-project-hub-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "axios": "^1.6.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.14.2"
+  },
+  "scripts": {
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject"
+  }
+}