My PPR Code

How my code meets College Board requirements

• 2 min read

Parts of PPR

List Creation

def generate_ai_response(self, user_input): try: response = self.chat_session.send_message(user_input) return response.text.rstrip("\n") if response.text else "Sorry, I couldn't process that."

Explanation:

This function processes chat interactions using a list stored within self.chat_session. The session maintains a conversation history internally, ensuring continuity in the chatbot’s responses. Each user input is added to the session’s history, allowing the AI to generate responses with context.

List Processing

def update_history(self, role: str, message: str): if len(self.history) >= self.MAX_HISTORY: self.history.pop(0) self.history.append({"role": role, "parts": [message]})

Explanation:

This function processes the self.history list by adding new messages and ensuring it does not exceed a set length. If the history reaches MAX_HISTORY, the oldest message is removed to maintain a manageable chat log.

Function (with paramaters, and if-else statement)

def post(self): try: data = request.get_json() if not data: return jsonify({"error": "Invalid JSON"}), 400

    user_input = data.get("user_input")
    if not user_input: 
        return jsonify({"error": "User input is required"}), 400

    user_message = AIMessage(message=user_input, author="user", category="user_message")
    db.session.add(user_message)
    db.session.commit()
    user_message_id = user_message.id  

    response_text = self.generate_ai_response(user_input)

    ai_message = AIMessage(message=response_text, author="assistant", category="ai_response")
    db.session.add(ai_message)
    db.session.commit()
    ai_message_id = ai_message.id  

    return jsonify({
        "user_message_id": user_message_id,
        "ai_message_id": ai_message_id,
        "user_input": user_input,
        "model_response": response_text
    })
except Exception as e:
    return jsonify({"error": str(e)}), 500  </code>

Explanation: This function handles a new chatbot interaction by accepting JSON input and extracting the user’s message. It ensures that the input is valid by checking if data and user_input are provided, returning an error if they are missing. The function then stores the user’s message in the database, generates an AI response using Google Generative AI, and saves the response. The function includes error handling to catch unexpected issues, ensuring smooth operation of the chatbot system.

Call to Function

response_text = self.generate_ai_response(user_input)

Explanation:

This line calls the generate_ai_response function to process the user’s input and return an AI-generated response. The function interacts with the Google Generative AI model to generate relevant replies based on the chatbot’s configuration. This ensures that every user input is processed and responded to dynamically, enhancing the chatbot’s functionality.

Sequencing

data = request.get_json() user_input = data.get("user_input") response_text = self.generate_ai_response(user_input)

Explanation:

The code sequences through data, user_input, and response_text.

Selection

try: data = request.get_json() if not data: return jsonify({"error": "Invalid JSON"}), 400

        user_input = data.get("user_input")
        if not user_input:
            return jsonify({"error": "User input is required"}), 400 </code>

Explanation:

This code will check different conditions using the if not statements, and returns the codes depending on the outcome of the request.

Iteration

for post in posts: json_ready.append(post.read())

Explanation:

This for loop will iterate over posts. Each post wil which is a collection of database objects. Each post is processed using .read(), converting it into a dictionary. The result is appended to json_ready, creating a structured list of processed data.

Summary:

List Creation: Used to maintain conversation history within self.chat_session, allowing the AI to generate responses with context. Function: Used to process user input, generate AI responses, and implement error handling to ensure robust chatbot interactions. Call to Function: Used to retrieve and process user messages, facilitating smooth communication between the chatbot and users. This structured API enables efficient AI-driven conversations by maintaining context, handling errors, and ensuring seamless interaction, providing users with a reliable and responsive chatbot experience.