technolyceum/ai7-m3
Template
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

updated

Browse Source
This commit is contained in:
root
2026-02-05 11:20:14 +03:00
parent 550619ba7c
commit 52b5f6f831
1 changed files with 343 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

538
ai_prompt.txt
View File

@@ -1,218 +1,366 @@
Based on your school scheduling system project, here's what the **API** would be: Here's a comprehensive AI prompt that will guide you through the entire process of analyzing CSV data, migrating to a database, and building a Python application to query it:
## **API Architecture for Your School Scheduling System** ## **Complete AI Prompt for CSV to Database Migration & Python App Development**
```text
I need to analyze CSV files containing school scheduling data and create a complete Python database system. Here's what I need:
## **PROJECT OVERVIEW**
I'm building a school scheduling system that migrates from spreadsheets to a database. I have CSV files with school data that needs to be analyzed, transformed, and loaded into a relational database, then queried through a Python application.
## **DATA ANALYSIS PHASE**
**1. CSV Structure Analysis:**
- Analyze these sample CSV files for structure and content:
- `students.csv` (student_id, name, grade, class_group)
- `teachers.csv` (teacher_id, name, subject, department)
- `schedule.csv` (entry_id, student_id, teacher_id, room, subject, day, time_slot, group_type)
- `subjects.csv` (subject_id, subject_name, level, requirements)
- `rooms.csv` (room_id, room_number, capacity, equipment)
**2. Data Quality Check:**
- Identify missing values, duplicates, and inconsistencies
- Check data types and formatting consistency
- Identify relationships between different CSV files
- Note any data normalization needs
**3. Schema Design:**
- Design a normalized SQL database schema based on CSV analysis
- Create ERD showing relationships
- Specify primary keys, foreign keys, and constraints
## **DATA MIGRATION PHASE**
**4. Python Migration Script:**
Create a Python script that:
- Reads CSV files using pandas
- Cleans and transforms data (handle missing values, format dates, normalize text)
- Creates SQLite database with proper schema
- Inserts data with error handling and validation
- Creates indexes for performance
- Generates migration logs and reports
**5. Migration Features:**
- Incremental data loading
- Rollback capability
- Data validation rules
- Performance optimization
- Error logging and reporting
## **DATABASE APPLICATION PHASE**
**6. Python Database Application:**
Build a Python application with these features:
**A. Core Query Functions:**
1. Student queries:
- Find student by name/id
- Get student schedule
- Find student location at specific time
- Get student's teachers and subjects
2. Teacher queries:
- Find teacher schedule
- Get teacher's students
- Find available rooms for teacher
3. Schedule queries:
- Room availability by time
- Schedule conflicts detection
- Daily/weekly schedule views
**B. Application Structure:**
- Database connection manager
- Query builder/ORM layer
- Business logic layer
- CLI interface
- API endpoints (optional)
- Error handling and logging
**C. Advanced Features:**
- Search functionality (full-text search)
- Export to CSV/Excel
- Data validation before insertion
- Audit logging
- Performance metrics
## **IMPLEMENTATION DETAILS**
**7. Technology Stack:**
- Python 3.8+
- SQLite (or PostgreSQL for production)
- pandas for data processing
- SQLAlchemy for ORM (optional)
- Flask/FastAPI for web interface (optional)
- pytest for testing
**8. File Structure:**
```
school_scheduler/
├── data/
│ ├── raw_csv/ # Original CSV files
│ ├── processed/ # Cleaned CSV files
│ └── database/ # SQLite database
├── src/
│ ├── migration/
│ │ ├── analyzer.py # CSV analysis
│ │ ├── cleaner.py # Data cleaning
│ │ └── loader.py # Database loading
│ ├── database/
│ │ ├── models.py # SQLAlchemy models
│ │ ├── connection.py # DB connection
│ │ └── queries.py # SQL queries
│ ├── app/
│ │ ├── cli.py # Command line interface
│ │ ├── api.py # REST API (optional)
│ │ └── scheduler.py # Business logic
│ └── utils/
│ ├── validators.py # Data validation
│ └── logger.py # Logging setup
├── tests/
│ ├── test_migration.py
│ ├── test_queries.py
│ └── test_app.py
├── requirements.txt
├── config.yaml # Configuration
└── README.md
```
**9. Step-by-Step Implementation:**
**Phase 1: Analysis & Design**
1. Analyze CSV file structures
2. Design database schema
3. Create ER diagram
4. Plan data transformation rules
**Phase 2: Migration Development**
1. Write CSV analyzer
2. Implement data cleaning functions
3. Create database schema
4. Build data loader with error handling
5. Add validation and logging
**Phase 3: Application Development**
1. Set up database connection
2. Implement core query functions
3. Create CLI interface
4. Add search and export features
5. Implement error handling
**Phase 4: Testing & Optimization**
1. Write unit tests
2. Test with sample data
3. Optimize queries
4. Add performance monitoring
## **SAMPLE DATA EXPECTATIONS**
CSV files may contain:
- Student data with multiple group affiliations
- Complex scheduling with time slots
- Room assignments with capacity constraints
- Teacher-subject relationships
- Overlapping
Perfect! Here's the optimized AI prompt for your specific setup:
## **Optimized AI Prompt for SQLite Database Migration**
```text
I'm building a school scheduling system migrating from CSV files to SQLite database. Here's my exact setup:
## **CURRENT SETUP**
- **Folder Structure**: `sample_data/` folder containing CSV files
- **Database Tool**: DB Browser for SQLite
- **Target Database**: SQLite database file (.db or .sqlite)
## **PHASE 1: CSV ANALYSIS & DATABASE DESIGN**
**1. Analyze CSV files in `sample_data/` folder:**
Please examine these CSV files (provide actual file names if known):
- `students.csv` - Student information
- `teachers.csv` - Teacher information
- `schedule.csv` - Scheduling data
- `subjects.csv` - Subject catalog
- `rooms.csv` - Room information
- Any other CSV files present
**2. For each CSV file, analyze:**
- Column names and data types
- Primary key candidates
- Data quality issues (nulls, duplicates, inconsistencies)
- Foreign key relationships to other files
- Sample data patterns
**3. Design SQLite database schema:**
- Create normalized tables based on CSV analysis
- Specify SQLite-compatible data types (TEXT, INTEGER, REAL, BLOB, NULL)
- Design primary keys (INTEGER PRIMARY KEY for autoincrement)
- Define foreign key constraints
- Create indexes for frequent queries
**4. Generate SQL schema for DB Browser SQLite:**
Provide CREATE TABLE statements that work in DB Browser SQLite.
## **PHASE 2: PYTHON MIGRATION SCRIPT**
**5. Create `migrate_to_sqlite.py` script that:**
- Reads all CSV files from `sample_data/` folder
- Uses pandas for data analysis and cleaning
- Creates SQLite database file
- Implements this workflow:
```python ```python
# The API is the "Application Programming Interface" - it's how different parts # Workflow:
# of your system communicate with each other and with external applications 1. Connect to SQLite database
2. Create tables from schema
## **WHAT IS THE API IN YOUR PROJECT?** 3. For each CSV file:
- Read with pandas
In your project, the API serves as the **middle layer** between: - Clean data (handle nulls, format, validate)
1. Your Telegram bot / Web interface - Insert into corresponding table
2. Your SQLite database - Log errors/success
3. Future mobile apps or parent portals 4. Create indexes
5. Generate migration report
## **API COMPONENTS:**
### **1. Database API Layer**
```python
# File: api/database.py
class DatabaseAPI:
"""API to interact with SQLite database"""
def get_student_schedule(self, student_id):
"""API method to get student schedule from database"""
# Connects to SQLite, runs query, returns JSON
pass
def find_student_location(self, student_name, time):
"""API to find where a student is at specific time"""
pass
def get_teacher_schedule(self, teacher_id):
"""API for teacher schedule queries"""
pass
``` ```
### **2. Telegram Bot API Integration** **6. Specific requirements for SQLite:**
```python - Use `sqlite3` Python module
# File: api/telegram_bot.py - Handle SQLite constraints (NOT NULL, UNIQUE, CHECK)
class TelegramBotAPI: - Use parameterized queries to prevent SQL injection
"""API that connects Telegram bot commands to database""" - Implement transaction rollback on errors
- Generate CSV import summary
def handle_whereis_command(self, student_name): **7. Data cleaning for SQLite compatibility:**
"""When user types /whereis, this API method is called""" - Convert dates to TEXT in ISO format (YYYY-MM-DD HH:MM:SS)
# 1. Receive command from Telegram - Handle empty strings vs NULL
# 2. Call DatabaseAPI.find_student_location() - Ensure integer fields are numeric
# 3. Format response for Telegram - Trim whitespace from TEXT fields
# 4. Send back to user
pass
def handle_schedule_command(self, student_name): ## **PHASE 3: PYTHON QUERY APPLICATION**
"""API for /schedule command"""
pass
```
### **3. Web API (REST API)** **8. Create `school_scheduler.py` application with:**
```python - SQLite database connection manager
# File: api/web_api.py - Query functions for common operations:
# This would be built with Flask or FastAPI
# Example API endpoints:
# GET /api/students/{id}/schedule - Get student schedule
# GET /api/teachers/{id}/classes - Get teacher classes
# GET /api/rooms/availability - Check room availability
# POST /api/schedule/update - Update schedule (admin)
```
## **HOW THE API WORKS IN YOUR SYSTEM:**
```
User Types: /whereis София
↓
Telegram Bot (Frontend)
↓
Calls: TelegramBotAPI.handle_whereis_command("София")
↓
Calls: DatabaseAPI.find_student_location("София", current_time)
↓
Executes SQL query on school_schedule.db
↓
Returns: {"student": "София", "room": "204", "subject": "Design"}
↓
Formats for Telegram: "София: Room 204, Design & Creativity"
↓
Sends to user
```
## **API ENDPOINTS IN YOUR PROJECT:**
### **For Telegram Bot:**
```
Internal API Methods:
- find_student(current_time, student_name) → returns location
- get_daily_schedule(student_id, date) → returns schedule
- get_teacher_schedule(teacher_id) → returns teacher classes
- check_room_availability(room_id, time_slot) → returns boolean
```
### **For Future Web Portal (REST API):**
```http
# Student endpoints
GET /api/v1/students # List all students
GET /api/v1/students/{id} # Get student details
GET /api/v1/students/{id}/schedule # Get student schedule
GET /api/v1/students/{id}/location # Get current location
# Teacher endpoints
GET /api/v1/teachers/{id}/schedule # Get teacher schedule
GET /api/v1/teachers/{id}/students # Get teacher's students
# Schedule endpoints
GET /api/v1/schedule/day/{date} # Daily schedule
GET /api/v1/schedule/room/{id} # Room schedule
POST /api/v1/schedule # Create schedule entry
PUT /api/v1/schedule/{id} # Update schedule
# Room endpoints
GET /api/v1/rooms # List all rooms
GET /api/v1/rooms/{id}/availability # Check room availability
```
## **API IN YOUR TECHNOLOGY STACK:**
```python ```python
# Your actual implementation (from your presentation): # Essential Queries:
1. Find student: "Where is [student] right now?"
# Telegram Bot → Python → SQLite Database 2. Student schedule: "Show [student]'s daily schedule"
# ↑ ↑ 3. Teacher schedule: "Show [teacher]'s classes"
# API Calls API Layer 4. Room availability: "Is [room] free at [time]?"
5. Schedule conflicts: "Find overlapping schedules"
# File: bot_api.py (simplified version of what you have)
import sqlite3
from datetime import datetime
class SchoolSchedulerAPI:
def __init__(self, db_path="school_schedule.db"):
self.db_path = db_path
self.connection = sqlite3.connect(db_path)
def api_whereis_student(self, student_name):
"""API method called by Telegram bot"""
query = """
SELECT s.name, r.room_number, sub.subject_name, t.name as teacher
FROM students s
JOIN schedule_entries se ON s.student_id = se.student_id
JOIN rooms r ON se.room_id = r.room_id
JOIN subjects sub ON se.subject_id = sub.subject_id
JOIN teachers t ON se.teacher_id = t.teacher_id
WHERE s.name = ? AND se.time_slot = ?
"""
current_time = datetime.now().strftime("%H:%M")
result = self.connection.execute(query, (student_name, current_time)).fetchone()
# API Response format
if result:
return {
"success": True,
"student": result[0],
"room": result[1],
"subject": result[2],
"teacher": result[3],
"time": current_time
}
else:
return {"success": False, "message": "Student not found"}
def api_get_schedule(self, student_name, date=None):
"""API to get full schedule"""
# Implementation similar to above
pass
``` ```
## **WHY YOU NEED AN API:** **9. Application features:**
- Command-line interface (CLI) with menu
- Interactive query builder
- Export results to CSV
- Error handling for SQLite errors
- Connection management (open/close)
1. **Separation of Concerns**: Database logic separate from bot logic **10. SQLite-specific optimizations:**
2. **Reusability**: Same API can be used by: - Use connection pooling
- Telegram Bot - Implement query caching if needed
- Web Portal - Add EXPLAIN QUERY PLAN for optimization
- Mobile App - Create views for complex queries
- Parent Dashboard
3. **Maintainability**: Change database without breaking bot
4. **Scalability**: Can add caching, load balancing
5. **Security**: Centralized authentication and validation
## **API IN YOUR FUTURE DEVELOPMENT:** ## **PHASE 4: DB BROWSER SQLITE INTEGRATION**
From your Slide 9 (Future Development): **11. Generate files for DB Browser SQLite:**
``` - SQL schema file (`.sql`) to import into DB Browser
Student/Parent portal → Needs API - Sample queries for DB Browser's "Execute SQL" tab
Staff portal → Needs API - Instructions for using DB Browser with the database
AI suggestions → Uses API to get data
Analytics → Uses API to query database **12. Create `db_browser_setup.sql` with:**
- All CREATE TABLE statements
- Sample INSERT statements
- Useful SELECT queries
- Index creation statements
## **DELIVERABLES REQUESTED**
Please provide:
**1. Database Schema:**
- Complete SQL CREATE TABLE statements for SQLite
- ER diagram showing relationships
- Index recommendations
**2. Python Scripts:**
- `analyze_csv.py` - Analyze sample_data CSV files
- `migrate_to_sqlite.py` - Migration script
- `school_scheduler.py` - Query application
- `requirements.txt` - Dependencies
**3. DB Browser Files:**
- `schema.sql` - Import into DB Browser
- `sample_queries.sql` - Pre-written queries
**4. Documentation:**
- README with setup instructions
- Sample queries and expected results
- Troubleshooting guide for SQLite issues
## **SAMPLE WORKFLOW**
```bash
# Expected workflow:
1. python analyze_csv.py # Analyze CSV files
2. python migrate_to_sqlite.py # Create and populate database
3. Open school_schedule.db in DB Browser # Visual verification
4. python school_scheduler.py # Run query application
``` ```
## **SUMMARY:** ## **ADDITIONAL REQUIREMENTS**
Your **API** is: **For SQLite Database:**
1. **The bridge** between Telegram bot and SQLite database - Database file: `school_schedule.db`
2. **A set of methods/functions** that handle specific requests - Enable foreign keys: `PRAGMA foreign_keys = ON`
3. **The business logic layer** that processes data - Use WAL journal mode for better concurrency
4. **Future-ready** for web/mobile applications - Implement backup mechanism
5. **Implemented in Python** using functions/classes that interface with sqlite3
**Current API Flow:** **For CSV Handling:**
``` - Detect CSV encoding automatically
User → Telegram → Your Python Code (API) → SQLite → Response → User - Handle different delimiters (comma, semicolon, tab)
- Skip malformed rows with logging
- Generate data quality report
**For Python Application:**
- Use argparse for CLI arguments
- Implement --help documentation
- Add verbose mode for debugging
- Include unit tests for key functions
Please analyze the CSV structure first, then provide the complete implementation.
``` ```
**Future API Flow:** ## **Quick Version (If you just want the code):**
```
Mobile App → HTTP Request → Web API (Flask/FastAPI) → SQLite → JSON Response → Mobile App ```text
Parent Portal → Same API → Same Database Build a Python system that:
1. Analyzes CSV files in `sample_data/` folder
2. Creates SQLite database (`school_schedule.db`)
3. Migrates CSV data to SQLite with cleaning
4. Provides query application for school scheduling
Key queries needed:
- Find student location by time
- Show student/teacher schedules
- Check room availability
- Detect schedule conflicts
Use: Python, sqlite3, pandas, DB Browser SQLite compatible.
``` ```
The API is what makes your system "intelligent" and accessible from multiple interfaces while keeping the database operations centralized and secure. ## **Best Practices to Include in Your Prompt:**
1. **Be specific about folder paths**: `sample_data/`
2. **Mention your tools**: DB Browser for SQLite
3. **Specify file formats**: `.db` or `.sqlite` extension
4. **List expected CSV files** if you know their names
5. **Mention specific queries** you need
6. **Include error handling requirements**
7. **Ask for DB Browser integration files**
This prompt will give you a complete, production-ready solution tailored to your exact setup with SQLite and DB Browser.