Upload 7 files

DOCKER_README.md

@@ -0,0 +1,10 @@
+---
+title: Flask App
+emoji: 🚀
+colorFrom: blue
+colorTo: red
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,555 @@
+import joblib
+from flask import Flask, render_template, request, jsonify,session
+from werkzeug.utils import secure_filename
+import os
+from student_functions import extract_text_from_pdf_s,generate_ai_response,generate_project_idea,generate_project_idea_questions,generate_quiz,generate_response_from_pdf,generate_step_by_step_explanation,perform_ocr,study_plan,ConversationBufferMemory,get_first_youtube_video_link,content_translate,summarise_text,content_translate
+from teacher_function import evaluate,extract_text_from_image,extract_text_from_pdf,generate_questions_from_text,generate_student_report,generate_timetable_module,cluster_topics,generate_timetable_weak
+import shutil
+from ai71 import AI71
+import re
+from flask import Flask, render_template, request, jsonify,session,current_app,send_from_directory
+
+AI71_API_KEY = "api71-api-df260d58-62e0-46c9-b549-62daa9c409be"
+UPLOAD_FOLDER = 'uploads'
+ALLOWED_EXTENSIONS =  {'pdf', 'jpg', 'jpeg' , 'png'}
+
+app = Flask(__name__)
+app.secret_key = 'your_unique_secret_key'  # Add this line
+if os.path.exists('uploads'):
+    shutil.rmtree('uploads')
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+memory = ConversationBufferMemory()
+database=joblib.load('database.pkl')
+teacher_data=database[0]
+student_data=database[1]
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/student')
+def student():
+    student = {
+        'name': session.get('student_name'),
+        'id': session.get('student_id'),
+        'school': session.get('student_school'),
+        'dob': session.get('student_dob'),
+        'email': session.get('student_email'),
+        'subjects_interested': session.get('student_subjects_interested', []),
+        'subjects_needing_improvement': session.get('student_subjects_needing_improvement', [])
+    }
+    return render_template('student.html', student=student)
+
+@app.route('/student_login', methods=['POST'])
+def student_login():
+    data = request.json
+    name = data.get('name')
+    password = data.get('password')
+
+    # Verify credentials
+    for student in student_data:
+        if student['name'] == name and student['password'] == password:
+            # Set session data
+            session['student_name'] = student['name']
+            session['student_id'] = student.get('id', 'N/A')  # If ID is not in data, default to 'N/A'
+            session['student_school'] = student['school']
+            session['student_dob'] = student['dob']
+            session['student_email'] = student['email']
+            session['student_subjects_interested'] = student['interests']
+            session['student_subjects_needing_improvement'] = [student['areas_to_improve']]
+            return jsonify({'success': True})
+
+    return jsonify({'success': False})
+
+
+@app.route('/teacher_login', methods=['POST'])
+def teacher_login():
+    data = request.json
+    name = data.get('name')
+    password = data.get('password')
+
+    # Verify credentials
+    for teacher in teacher_data:
+        if teacher['name'] == name and teacher['password'] == password:
+            # Set session data
+            session['teacher_name'] = teacher['name']
+            session['teacher_id'] = teacher['teacher_id']
+            session['teacher_school'] = teacher['school']
+            session['teacher_dob'] = teacher['date_of_birth']
+            session['teacher_email'] = teacher['email']
+            session['teacher_subjects_taught'] = teacher['subjects_taught']
+            session['teacher_classes'] = teacher['classes']
+            session['teacher_performance'] = teacher['teaching_performance']
+            session['teacher_qualifications'] = teacher['qualifications']
+            session['teacher_years_of_experience'] = teacher['years_of_experience']
+            session['weekly_class_performance']= teacher['weekly_class_performance']
+            return jsonify({'success': True})
+
+    return jsonify({'success': False})
+
+@app.route('/teacher')
+def teacher():
+    teacher = {
+        'name': session.get('teacher_name'),
+        'id': session.get('teacher_id'),
+        'school': session.get('teacher_school'),
+        'dob': session.get('teacher_dob'),
+        'email': session.get('teacher_email'),
+        'subjects_taught': session.get('teacher_subjects_taught', []),
+        'classes': session.get('teacher_classes', []),
+        'performance': session.get('teacher_performance', {}),
+        'qualifications': session.get('teacher_qualifications', []),
+        'years_of_experience': session.get('teacher_years_of_experience', 0),
+        'weekly_class_performance': session.get('teacher_weekly_class_performance', {})
+    }
+    return render_template('teacher.html', teacher=teacher)
+
+@app.route('/student_pdfqa', methods=['GET', 'POST'])
+def student_pdfqa():
+    if request.method == 'POST':
+        file = request.files.get('pdf-file')
+        if file and allowed_file(file.filename):
+            filename = secure_filename(file.filename)
+            file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(file_path)
+
+            pdf_text = extract_text_from_pdf_s(file_path)
+            return jsonify({'message': f'PDF uploaded and processed. You can now ask questions.', 'pdf_text': pdf_text})
+        else:
+            return jsonify({'message': 'Invalid file type. Please upload a PDF.'}), 400
+
+    return render_template('student_pdfqa.html')
+
+@app.route('/ask_pdf_question', methods=['POST'])
+def ask_pdf_question():
+    data = request.json
+    query = data['query']
+    pdf_text = data['pdf_text']
+
+    response = generate_response_from_pdf(query, pdf_text)[:-6]
+    return jsonify({'response': response})
+
+@app.route('/student_aitutor')
+def student_aitutor():
+    return render_template('student_aitutor.html')
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.json
+    query = data['message']
+    response = generate_ai_response(query)
+    return jsonify({'response': response})
+
+@app.route('/upload_image_for_ocr', methods=['POST'])
+def upload_image_for_ocr():
+    if 'image-file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+    file = request.files['image-file']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+    if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(file_path)
+
+        extracted_text = perform_ocr(file_path)
+        ai_response = generate_ai_response(extracted_text)
+
+        return jsonify({'ai_response': ai_response})
+    return jsonify({'error': 'Invalid file type'}), 400
+
+
+@app.route('/student_projectideas')
+def student_projectideas():
+    return render_template('student_projectideas.html')
+
+@app.route('/student_quiz')
+def student_quiz():
+    return render_template('student_quiz.html')
+
+@app.route('/update_student_areas', methods=['POST'])
+def update_student_areas():
+    data = request.json
+    student_id = data.get('student_id')
+    areas_to_improve = data.get('areas_to_improve')
+
+    # Find the student in the database
+    student = next((s for s in student_data if s['email'] == student_id), None)
+
+    if student:
+        # Update the student's areas to improve
+        student['areas_to_improve'] = areas_to_improve
+        return jsonify({'status': 'success'})
+    else:
+        return jsonify({'status': 'error', 'message': 'Student not found'}), 404
+@app.route('/get_student_profile', methods=['GET'])
+def get_student_profile():
+    # For demonstration, assume `student_id` is passed in query parameters
+    student_id = request.args.get('student_id')
+    student = next((s for s in student_data if s['email'] == student_id), None)
+
+    if student:
+        return jsonify({
+            'status': 'success',
+            'areas_to_improve': student.get('areas_to_improve', [])
+        })
+    else:
+        return jsonify({'status': 'error', 'message': 'Student not found'}), 404
+
+
+def calculate_score_and_grade(llm_response):
+    pattern = r'Assigned marks: (\d+)/(\d+)'
+    matches = re.findall(pattern, llm_response)
+
+    total_score = sum(int(score) for score, max_score in matches)
+    max_possible_score = sum(int(max_score) for score, max_score in matches)
+
+    percentage = (total_score / max_possible_score) * 100 if max_possible_score > 0 else 0
+
+    if percentage > 90:
+        grade = 'O'
+    elif 80 <= percentage <= 90:
+        grade = 'A'
+    elif 70 <= percentage < 80:
+        grade = 'B'
+    elif 60 <= percentage < 70:
+        grade = 'C'
+    elif 50 <= percentage < 60:
+        grade = 'D'
+    else:
+        grade = 'Fail'
+
+    return total_score, max_possible_score, percentage, grade
+@app.route('/student_reward_points')
+def student_reward_points():
+    return render_template('student_reward_points.html')
+
+@app.route('/generate_quiz', methods=['POST'])
+def generate_quiz_route():
+    data = request.json
+    subject = data['subject']
+    topic = data['topic']
+    count = int(data['num-questions'])
+    difficulty = data['difficulty']
+
+    quiz = generate_quiz(subject, topic, count, difficulty)
+    return jsonify({'quiz': quiz})
+
+@app.route('/generate_project_idea', methods=['POST'])
+def generate_project_idea_route():
+    data = request.json
+    subject = data['subject']
+    topic = data['topic']
+    plan = data['plan']
+
+    project_idea = generate_project_idea(subject, topic, plan)
+    return jsonify({'project_idea': project_idea})
+
+@app.route('/homework')
+def homework():
+    return render_template('homework.html')
+
+@app.route('/student_courses')
+def student_courses():
+    return render_template('student_courses.html')
+
+@app.route('/search_youtube', methods=['POST'])
+def search_youtube():
+    data = request.json
+    query = data['query']
+
+    try:
+        video_link, video_title = get_first_youtube_video_link(query)
+        video_id = video_link.split('v=')[1]
+        return jsonify({
+            'videoId': video_id,
+            'videoTitle': video_title
+        })
+    except Exception as e:
+        return jsonify({'error': f'An error occurred: {str(e)}'}), 500
+
+@app.route('/ask_followup', methods=['POST'])
+def ask_followup_route():
+    data = request.json
+    project_idea = data['project_idea']
+    query = data['query']
+
+    response = generate_project_idea_questions(project_idea, query)
+    return jsonify({'response': response})
+
+@app.route('/student_studyplans')
+def student_studyplans():
+    return render_template('student_studyplans.html')
+
+@app.route('/generate_study_plan', methods=['POST'])
+def generate_study_plan_route():
+    data = request.json
+    subjects = data['subjects']
+    hours = data['hours']
+    area_lag = data['areaLag']  # Ensure the key matches
+    goal = data['goal']
+    learning_style = data['learningStyle']
+
+    study_plan_text = study_plan(subjects, hours, area_lag, goal)
+    return jsonify({'study_plan': study_plan_text})
+
+
+@app.route('/student_stepexplanation')
+def student_stepexplanation():
+    return render_template('student_stepexplanation.html')
+
+
+@app.route('/evaluate-answers', methods=['POST'])
+def evaluate_answers():
+    data = request.json
+    questions = data['questions']
+    answers = data['answers']
+    max_marks = 5  # As per your requirement
+
+    evaluations = []
+    for question, answer in zip(questions, answers):
+        if answer.strip() == "":
+            evaluation = "Description: No answer provided.\nAssigned marks: 0\nTotal marks: 5"
+        else:
+            evaluation = evaluate(question, answer, max_marks)
+        evaluations.append(evaluation)
+
+    return jsonify({"evaluations": evaluations})
+
+@app.route('/translate', methods=['POST'])
+def translate():
+    data = request.json
+    text = data.get('text', '')
+    # Mock translation function
+    translated_text = content_translate(text)
+    return jsonify({"translated_text": translated_text})
+
+@app.route('/generate_step_by_step_explanation', methods=['POST'])
+def generate_step_by_step_explanation_route():
+    data = request.get_json()
+    question = data['question']
+    answer = generate_step_by_step_explanation(question)
+    return jsonify({'answer': answer})
+
+@app.route('/speak')
+def speak():
+    return render_template('student_speakai.html')
+
+@app.route('/generate_ai_timetable', methods=['POST'])
+def generate_ai_timetable():
+    academic_topics = request.form['academic_topics'].split(',')
+    hours_per_day = request.form['hours_per_day']
+
+    clustered_topics = cluster_topics(academic_topics)
+    special_timetable = generate_timetable_weak(clustered_topics, hours_per_day)
+
+    return jsonify({
+        'clustered_topics': clustered_topics,
+        'special_timetable': special_timetable
+    })
+
+
+@app.route('/ai_timetable')
+def ai_timetable():
+    return render_template('ai_timetable.html')
+
+@app.route('/summarise_video')
+def summarise_video():
+    return render_template('student_summarise_video.html')
+
+@app.route('/summarize_video', methods=['POST'])
+def summarize_video_route():
+    data = request.json
+    url = data.get('url')
+    if url:
+        try:
+            summary = summarise_text(url)
+            return jsonify({'summary': summary})
+        except Exception as e:
+            return jsonify({'error': str(e)}), 500
+    else:
+        return jsonify({'error': 'No URL provided'}), 400
+
+
+@app.route('/generate-questions-hw', methods=['GET'])
+def generate_questions():
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": (
+            "Generate 5 questions for a Math Assignment on 'trigonometry Basics'. "
+            "Include a mix of both theoretical and numerical questions."
+        )}
+    ]
+
+    questions = []
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=messages,
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            questions.append(chunk.choices[0].delta.content)
+
+    # Join all chunks to create the complete list of questions
+    complete_questions = ''.join(questions).split('\n')
+
+    return jsonify({'questions': complete_questions})
+
+@app.route('/assign_grade', methods=['POST'])
+def assign_grade():
+    data = request.json
+    result = data['result']
+    total_score, max_possible_score, percentage, grade = calculate_score_and_grade(result)
+    return jsonify({
+        'total_score': total_score,
+        'max_possible_score': max_possible_score,
+        'percentage': percentage,
+        'grade': grade
+    })
+
+@app.route('/generate_timetable', methods=['POST'])
+def generate_timetable():
+    data = request.json
+    hours_per_day = data.get('hours_per_day')
+    days_per_week = data.get('days_per_week')
+    semester_end_date = data.get('semester_end_date')
+    subjects = data.get('subjects', [])
+
+    # Input validation
+    if not hours_per_day or not days_per_week or not semester_end_date or not subjects:
+        return jsonify({"error": "Missing required parameters"}), 400
+
+    try:
+        timetable=generate_timetable_module(data,hours_per_day,days_per_week,semester_end_date,subjects)
+
+        return jsonify({"timetable": timetable})
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/generate-paper', methods=['GET', 'POST'])
+def generate_paper():
+    if request.method == 'POST':
+        no_of_questions = int(request.form['no_of_questions'])
+        total_marks = int(request.form['total_marks'])
+        no_of_parts = int(request.form['no_of_parts'])
+        marks_per_part = int(request.form['marks_per_part'])
+        test_duration = request.form['test_duration']
+        pdf_file = request.files['pdf_file']
+
+        if pdf_file:
+            # Secure the file name and save the file to the upload folder
+            filename = secure_filename(pdf_file.filename)
+            file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            pdf_file.save(file_path)
+
+            # Extract text from the curriculum PDF
+            curriculum_text = extract_text_from_pdf(file_path)
+
+            # Generate questions
+            questions = generate_questions_from_text(curriculum_text, no_of_questions, marks_per_part, no_of_parts)
+
+            # Optionally, remove the saved file after use
+            os.remove(file_path)
+
+            return render_template('teacher_paper_gen.html', questions=questions)
+
+    return render_template('teacher_paper_gen.html')
+
+
+@app.route('/eval', methods=['GET', 'POST'])
+def eval():
+    if request.method == 'POST':
+        input_type = request.form['input_type']
+        question_text = ""
+        answer_text = ""
+        max_marks = request.form['max_marks']
+
+        if input_type == 'file':
+            question_file = request.files['question_file']
+            answer_file = request.files['answer_file']
+
+            if question_file and answer_file:
+                question_path = os.path.join(app.config['UPLOAD_FOLDER'], question_file.filename)
+                answer_path = os.path.join(app.config['UPLOAD_FOLDER'], answer_file.filename)
+
+                question_file.save(question_path)
+                answer_file.save(answer_path)
+
+                if question_path.endswith('.pdf'):
+                    question_text = extract_text_from_pdf(question_path)
+                else:
+                    question_text = extract_text_from_image(question_path)
+
+                if answer_path.endswith('.pdf'):
+                    answer_text = extract_text_from_pdf(answer_path)
+                else:
+                    answer_text = extract_text_from_image(answer_path)
+
+        elif input_type == 'text':
+            question_text = request.form['question_text']
+            answer_text = request.form['answer_text']
+
+        evaluation_result = evaluate(question_text, answer_text, max_marks)
+        print(f"Question Text: {question_text}")  # Debugging line
+        print(f"Answer Text: {answer_text}")  # Debugging line
+        print(f"Evaluation Result: {evaluation_result}")  # Debugging line
+
+        return render_template('teacher_result.html', result=evaluation_result)
+
+    return render_template('teacher_eval.html')
+
+@app.route('/get_students')
+def get_students():
+
+    return jsonify(student_data)
+
+
+@app.route('/get_audio_files', methods=['GET'])
+def get_audio_files():
+    audio_folder = os.path.join(app.root_path, 'speech')
+    audio_files = [{'name': file, 'url': f'/speech/{file}'} for file in os.listdir(audio_folder) if
+                   file.endswith('.mp3')]
+
+    current_app.logger.info(f"Found audio files: {audio_files}")
+
+    return jsonify({'audio_files': audio_files})
+
+
+@app.route('/speech/<path:filename>')
+def serve_audio(filename):
+    return send_from_directory(os.path.join(app.root_path, 'speech'), filename)
+
+
+
+@app.route('/generate_report', methods=['POST'])
+def generate_report():
+    student_data = request.json
+    report = generate_student_report(
+        student_data['name'],
+        student_data['age'],
+        student_data['cgpa'],
+        student_data['course_pursuing'],
+        student_data['assigned_test_score'],
+        student_data['ai_test_score'],
+        student_data['interests'],
+        student_data['areas_to_improve'],
+        student_data['courses_taken']
+    )
+    return jsonify({'report': report})
+
+
+
+
+if __name__ == '__main__':
+    if os.path.exists('uploads'):
+        shutil.rmtree('uploads')
+        os.makedirs('uploads')
+    else:
+        os.makedirs('uploads')
+    app.run( port=5000, debug=True)
+

database.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c31f0fc600fc2250c17e3e1424bcf4d3af772b8a0ca32bd95661771dd213354
+size 3124

requirements.txt

@@ -0,0 +1,15 @@
+Flask
+Werkzeug
+selenium
+easyocr
+youtube-transcript-api
+pypdf
+PyPDF2
+pdf2image
+opencv-python-headless
+numpy
+pytesseract
+joblib
+requests
+ai71
+setuptools

student_functions.py

@@ -0,0 +1,362 @@
+from gtts import gTTS
+import shutil
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+import easyocr
+import json
+from youtube_transcript_api import YouTubeTranscriptApi
+from youtube_transcript_api.formatters import JSONFormatter
+from urllib.parse import urlparse, parse_qs
+from pypdf import PdfReader
+from ai71 import AI71
+import os
+
+AI71_API_KEY = "api71-api-df260d58-62e0-46c9-b549-62daa9c409be"
+
+
+def extract_text_from_pdf_s(pdf_path):
+    text = ""
+    reader = PdfReader(pdf_path)
+    for page in reader.pages:
+        text += page.extract_text() + "\n"
+    generate_speech_from_pdf(text[:len(text) // 2])
+    return text
+
+
+def generate_response_from_pdf(query, pdf_text):
+    response = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a pdf questioning assistant."},
+                {"role": "user",
+                 "content": f'''Answer the querry based on the given content.Content:{pdf_text},query:{query}'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            response += chunk.choices[0].delta.content
+    return response[:-6].replace("###", '')
+
+
+def generate_quiz(subject, topic, count, difficult):
+    quiz_output = ""
+
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a teaching assistant."},
+                {"role": "user",
+                 "content": f'''Generate {count} multiple-choice questions in the subject of {subject} for the topic {topic} for students at a {difficult} level. Ensure the questions are well-diversified and cover various aspects of the topic. Format the questions as follows:
+Question: [Question text] [specific concept in a question] 
+<<o>> [Option1] 
+<<o>> [Option2] 
+<<o>> [Option3] 
+<<o>> [Option4], 
+Answer: [Option number]'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            quiz_output += chunk.choices[0].delta.content
+    print("Quiz generated")
+    return quiz_output
+
+
+def perform_ocr(image_path):
+    reader = easyocr.Reader(['en'])
+    try:
+        result = reader.readtext(image_path)
+        extracted_text = ''
+        for (bbox, text, prob) in result:
+            extracted_text += text + ' '
+        return extracted_text.strip()
+    except Exception as e:
+        print(f"Error during OCR: {e}")
+        return ''
+
+
+def generate_ai_response(query):
+    ai_response = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a teaching assistant."},
+                {"role": "user", "content": f'Assist the user clearly for his questions: {query}.'},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            ai_response += chunk.choices[0].delta.content
+    return ai_response.replace('###', '')[:-6]
+
+
+def generate_project_idea(subject, topic, overview):
+    string = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a project building assistant."},
+                {"role": "user",
+                 "content": f'''Give the different project ideas to build project in {subject} specifically in {topic} for school students. {overview}.'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            string += chunk.choices[0].delta.content
+    return string
+
+
+def generate_project_idea_questions(project_idea, query):
+    project_idea_answer = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a project building assistant."},
+                {"role": "user",
+                 "content": f'''Assist me clearly for the following question for the given idea. Idea: {project_idea}. Question: {query}'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            project_idea_answer += chunk.choices[0].delta.content
+    return project_idea_answer
+
+
+def generate_step_by_step_explanation(query):
+    explanation = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are the best teaching assistant."},
+                {"role": "user",
+                 "content": f'''Provide me the clear step by step explanation answer for the following question. Question: {query}'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            explanation += chunk.choices[0].delta.content
+    return explanation.replace('###', '')
+
+
+def study_plan(subjects, hours, arealag, goal):
+    plan = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are the best teaching assistant."},
+                {"role": "user",
+                 "content": f'''Provide me the clear personalised study plan for the subjects {subjects} i lag in areas like {arealag}, im available for {hours} hours per day and my study goal is to {goal}.Provide me like a timetable like day1,day2 for 5 days with concepts,also suggest some books'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            plan += chunk.choices[0].delta.content
+    return plan.replace('\n', '<br>')
+
+
+class ConversationBufferMemory:
+    def __init__(self, memory_key="chat_history"):
+        self.memory_key = memory_key
+        self.buffer = []
+
+    def add_to_memory(self, interaction):
+        self.buffer.append(interaction)
+
+    def get_memory(self):
+        return "\n".join([f"Human: {entry['user']}\nAssistant: {entry['assistant']}" for entry in self.buffer])
+
+
+def spk_msg(user_input, memory):
+    chat_history = memory.get_memory()
+    msg = ''
+
+    # Construct the message for the API request
+    messages = [
+        {"role": "system",
+         "content": "You are a nice speaker having a conversation with a human.You ask the question the user choose the topic and let user answer.Provide the response only within 2 sentence"},
+        {"role": "user",
+         "content": f"Previous conversation:\n{chat_history}\n\nNew human question: {user_input}\nResponse:"}
+    ]
+
+    try:
+        for chunk in AI71(AI71_API_KEY).chat.completions.create(
+                model="tiiuae/falcon-180b-chat",
+                messages=messages,
+                stream=True,
+        ):
+            if chunk.choices[0].delta.content:
+                msg += chunk.choices[0].delta.content
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+    return msg
+
+
+def get_first_youtube_video_link(query):
+    chrome_options = webdriver.ChromeOptions()
+    chrome_options.add_argument("--headless")
+    chrome_options.add_argument("--disable-gpu")
+    chrome_options.add_argument("--disable-extensions")
+    chrome_options.add_argument("--no-sandbox")
+    chrome_options.add_argument("--disable-dev-shm-usage")
+    driver = webdriver.Chrome(options=chrome_options)
+    try:
+        driver.get('https://www.youtube.com')
+        search_box = driver.find_element(By.NAME, 'search_query')
+        search_box.send_keys(query)
+        search_box.send_keys(Keys.RETURN)
+        WebDriverWait(driver, 10).until(
+            EC.presence_of_element_located((By.CSS_SELECTOR, 'a#video-title')))
+        first_video = driver.find_element(By.CSS_SELECTOR, 'a#video-title')
+        first_video_link = first_video.get_attribute('href')
+        video_title = first_video.get_attribute('title')
+        return first_video_link, video_title
+    finally:
+        driver.quit()
+    return
+
+
+def content_translate(text):
+    translated_content = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are the best teaching assistant."},
+                {"role": "user", "content": f'''Translate the text to hindi. Text: {text}'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            translated_content += chunk.choices[0].delta.content
+    return translated_content
+
+
+def get_video_id(url):
+    """
+    Extract the video ID from a YouTube URL.
+    """
+    parsed_url = urlparse(url)
+    if parsed_url.hostname == 'www.youtube.com' or parsed_url.hostname == 'youtube.com':
+        video_id = parse_qs(parsed_url.query).get('v')
+        if video_id:
+            return video_id[0]
+    elif parsed_url.hostname == 'youtu.be':
+        return parsed_url.path[1:]
+    return None
+
+
+def extract_captions(video_url):
+    """
+    Extract captions from a YouTube video URL.
+    """
+    video_id = get_video_id(video_url)
+    if not video_id:
+        print("Invalid YouTube URL.")
+        return
+
+    try:
+        transcript = YouTubeTranscriptApi.get_transcript(video_id)
+        formatter = JSONFormatter()
+        formatted_transcript = formatter.format_transcript(transcript)
+
+        # Save captions to a file
+        with open(f'youtube_captions.json', 'w') as file:
+            file.write(formatted_transcript)
+
+        print("Captions have been extracted and saved as JSON.")
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+
+def extract_text_from_json(filename):
+    # Open and read the JSON file
+    with open(filename, 'r') as file:
+        data = json.load(file)
+
+    # Extract and print the text fields
+    texts = [entry['text'] for entry in data]
+    return texts
+
+
+def get_simplified_explanation(text):
+    prompt = (
+        f"The following is a transcript of a video: \n\n{text}\n\n"
+        "Please provide a simplified explanation of the video for easy understanding."
+    )
+
+    response = ""
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            response += chunk.choices[0].delta.content
+
+    return response
+
+
+def summarise_text(url):
+    extract_captions(url)
+    texts = extract_text_from_json(r'youtube_captions.json')
+    os.remove('youtube_captions.json')
+
+    first_half = (get_simplified_explanation(texts[:len(texts) // 2]))[:-6]
+    second_half = (get_simplified_explanation(texts[len(texts) // 2:]))[:-6]
+    return (first_half + second_half)
+
+
+def generate_speech_from_pdf(content):
+    if os.path.exists('speech'):
+        shutil.rmtree('speech')
+        os.makedirs('speech', exist_ok=True)
+    else:
+        os.makedirs('speech', exist_ok=True)
+
+    speech = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a summarising assistant."},
+                {"role": "user",
+                 "content": f'''Summarise the given content for each chapter for 1 sentence.Content={content}'''},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            speech += chunk.choices[0].delta.content
+    speech = speech[:-6].replace("###", '')
+    chapters = speech.split('\n\n')
+    pdf_audio(chapters[:4])
+    return
+
+
+def pdf_audio(chapters):
+    for i in range(len(chapters)):
+        tts = gTTS(text=chapters[i], lang='en', slow=False)
+        tts.save(f'speech/chapter {i + 1}.mp3')
+    return
+
+def content_translate(text):
+
+
+    translated_content = ''
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+        model="tiiuae/falcon-180b-chat",
+        messages=[
+            {"role": "system", "content": "You are the best teaching assistant."},
+            {"role": "user", "content": f'''Translate the text to hindi. Text: {text}'''},
+        ],
+        stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            translated_content += chunk.choices[0].delta.content
+    return translated_content

teacher_function.py

@@ -0,0 +1,158 @@
+from ai71 import AI71
+from PyPDF2 import PdfReader
+from pdf2image import convert_from_path
+import cv2
+import numpy as np
+import pytesseract
+AI71_API_KEY = "api71-api-20725a9d-46d6-4baf-9e26-abfca35ab242"
+
+def extract_text_from_pdf(pdf_file):
+    text = ""
+    reader = PdfReader(pdf_file)
+    for page in reader.pages:
+        text += page.extract_text()
+    return text
+
+def generate_questions_from_text(text, no_of_questions, marks_per_part, no_parts):
+    ai71 = AI71(AI71_API_KEY)
+    messages = [
+        {"role": "system", "content": "You are a teaching assistant"},
+        {"role": "user",
+         "content": f"Give your own {no_of_questions} questions under each part for {no_parts} parts with {marks_per_part} marks for each part. Note that all questions must be from the topics of {text}"}
+    ]
+
+    questions = []
+    for chunk in ai71.chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=messages,
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            questions.append(chunk.choices[0].delta.content)
+
+    return "".join(questions)
+
+def extract_text_from_image(image_path):
+    img = cv2.imread(image_path)
+    text = pytesseract.image_to_string(img)
+    return text
+
+
+def extract_text_from_pdf(pdf_path):
+    images = convert_from_path(pdf_path)
+    final_text = ""
+    for image in images:
+        image_cv = np.array(image)
+        image_cv = cv2.cvtColor(image_cv, cv2.COLOR_RGB2BGR)
+        text = pytesseract.image_to_string(image_cv)
+        final_text += text
+    return final_text
+
+
+def evaluate(question, answer, max_marks):
+    prompt = f"""Questions: {question}
+    Answer: {answer}.
+
+
+    Evaluate above questions one by one(if there are multiple) by provided answers and assign marks out of {max_marks}. No need overall score. Note that as maximum mark increases, the size of the answer must be large enough to get good marks. Give ouput in format below:
+description: 
+assigned marks: 
+total marks: 
+Note that you should not display total marks"""
+
+    messages = [
+        {"role": "system", "content": "You are an answer evaluator"},
+        {"role": "user", "content": prompt}
+    ]
+
+    response_content = ""
+    for chunk in  AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=messages,
+            stream=True
+    ):
+        if chunk.choices[0].delta.content:
+            response_content += chunk.choices[0].delta.content
+
+    return response_content
+
+def generate_student_report(name, age, cgpa, course, assigned_test, ai_test, interests, difficulty, courses_taken):
+    prompt = f"""
+    Name: {name}
+    Age: {age}
+    CGPA: {cgpa}
+    Course: {course}
+    Assigned Test Score: {assigned_test}
+    AI generated Test Score: {ai_test}
+    Interests: {interests}
+    Difficulty in: {difficulty}
+    Courses Taken: {courses_taken}
+    Use the above student data to generate a neat personalized report and suggested teaching methods."""
+
+    client = AI71(AI71_API_KEY)
+
+    response = client.chat.completions.create(
+        model="tiiuae/falcon-180B-chat",
+        messages=[
+            {"role": "system", "content": "You are a student report generator."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    report = response.choices[0].message.content if response.choices and response.choices[
+        0].message else "No report generated."
+    print(report)
+
+    return report.replace('\n','<br>')
+def generate_timetable_module(data,hours_per_day,days_per_week,semester_end_date,subjects):
+    response = AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180B-chat",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": f"Create a timetable starting from Monday based on the following inputs:\n"
+                                            f"- Number of hours per day: {hours_per_day}\n"
+                                            f"- Number of days per week: {days_per_week}\n"
+                                            f"- Semester end date: {semester_end_date}\n"
+                                            f"- Subjects: {', '.join(subjects)}\n"}
+            ]
+        )
+
+        # Access the response content correctly
+    return( response.choices[0].message.content if response.choices and response.choices[0].message else "No timetable generated.")
+
+def cluster_topics(academic_topics):
+    prompt = (
+            "Please cluster the following academic topics into their respective subjects such as Mathematics, Physics, etc.: "
+            + ", ".join(academic_topics))
+    response = ""
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            response += chunk.choices[0].delta.content
+    return response
+
+def generate_timetable_weak(clustered_subjects, hours_per_day):
+    prompt = (
+        f"Using the following subjects and topics:\n{clustered_subjects}\n"
+        f"Generate a special class timetable for {hours_per_day} hours per day.\n"
+        f"Also provide reference books and methods to teach the slow learners for each subject"
+    )
+    response = ""
+    for chunk in AI71(AI71_API_KEY).chat.completions.create(
+            model="tiiuae/falcon-180b-chat",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt},
+            ],
+            stream=True,
+    ):
+        if chunk.choices[0].delta.content:
+            response += chunk.choices[0].delta.content
+    return response
+