import pandas as pd
import sys
sys.path.append(r"C:\Users\silvh\OneDrive\lighthouse\custom_python")
from silvhua import *
# set the option to wrap text within cells
pd.set_option('display.max_colwidth', None)
pd.set_option('display.max_rows', 10)
pd.set_option('display.max_columns', None)
pd.set_option('display.width', None)

import json
import requests

with open("../online-PT-social-media-NLP/notebooks/credentials.json") as f:
    credentials = json.load(f)

ig_user_id = credentials['am_ig_user_id']
access_token = credentials['am_fb_access_token']
group_id = credentials['SSC_group_id']

posts_data_dict = dict()
posts_df_dict = dict()
comments_response_dict = dict()
comments_df_dict = dict()
replies_dict = dict()

def get_facebook_posts(group_id, access_token, limit=30):
    """
    Makes a GET request to pull posts from a Facebook group using the Facebook API.
    Outputs the results into a DataFrame so that each post is a row along with its time stamp, message,
    permalink, comments count, reactions, and post ID.
    Also outputs the response.json().

    Parameters:
        group_id (str): The ID of the Facebook group to pull posts from.
        access_token (str): An access token with the appropriate permissions to access the group's content.
        limit (int): The number of posts to retrieve (default is 100).

    Returns:
        pandas.DataFrame: A DataFrame containing the posts and their associated data.
    """
    url = f"https://graph.facebook.com/{group_id}/feed"

    params = {
        "access_token": access_token,
        "fields": "created_time,message,permalink_url,comments.limit(10).summary(true),reactions.limit(500).summary(true).type(LIKE).as(like),reactions.limit(500).summary(true).type(LOVE).as(love),reactions.limit(500).summary(true).type(WOW).as(wow),reactions.limit(500).summary(true).type(HAHA).as(haha),reactions.limit(500).summary(true).type(SAD).as(sad),reactions.limit(500).summary(true).type(ANGRY).as(angry)",
        "limit": limit
    }
    response = requests.get(url, params=params)
    status_code = response.status_code
    print("Response Status Code:", status_code)
    data = response.json()
    return data

## I will use this as part of the final code for the task
def process_response(data):
    posts = []
    comments = []
    for post in data["data"]:
        created_time = post.get("created_time")
        message = post.get("message")
        permalink_url = post.get("permalink_url")
        comments_count = post.get("comments", {}).get("summary", {}).get("total_count", 0)
        reactions = post.get("like", {}).get("summary", {}).get("total_count", 0), post.get("love", {}).get("summary", {}).get("total_count", 0), post.get("wow", {}).get("summary", {}).get("total_count", 0), post.get("haha", {}).get("summary", {}).get("total_count", 0), post.get("sad", {}).get("summary", {}).get("total_count", 0), post.get("angry", {}).get("summary", {}).get("total_count", 0)
        post_id = post.get("id")
        posts.append({
            "post_id": post_id,
            "created_time": created_time,
            "message": message,
            "comments_count": comments_count,
            "like_count": reactions[0],
            "love_count": reactions[1],
            "wow_count": reactions[2],
            "haha_count": reactions[3],
            "sad_count": reactions[4],
            "angry_count": reactions[5],
            "permalink_url": permalink_url,
        })

    df = pd.DataFrame(posts)
    # Reorder columns
    df = df[["post_id", "created_time", "message", "comments_count", "like_count", "love_count", "wow_count", "haha_count", "sad_count", "angry_count", "permalink_url"]]
    
    return df

def get_fb_comments(group_id, access_token, limit=30):
    """
    Pulls comments from a Facebook group using the Facebook API and outputs the results into a pandas DataFrame.
    
    Parameters:
    group_id (str): The ID of the Facebook group to pull comments from.
    access_token (str): A Facebook access token with the necessary permissions to access the group.
    
    Returns:
    Tuple(pandas.DataFrame, dict): A tuple containing a DataFrame with each comment as a row along with its details and replies,
    and the full JSON response from the API.
    """
    # Set up the API endpoint and parameters
    url = f"https://graph.facebook.com/{group_id}/feed"
    params = {
        "fields": "comments{created_time,message,from,comments{created_time,message,from}}",
        "access_token": access_token,
        "limit": limit
    }

    # Make the GET request
    response = requests.get(url, params=params)
    
    # Convert the response to a DataFrame
    comments = []
    for post in response.json()["data"]:
        post_comments = post.get("comments", {}).get("data", [])
        for comment in post_comments:
            comment_dict = {
                "post_id": post.get("id"),
                "created_time": comment.get("created_time"),
                "message": comment.get("message"),
                "author_id": comment.get("from", {}).get("id"),
                "author_name": comment.get("from", {}).get("name"),
                "parent_id": None,
                "parent_name": None,
            }
            parent_comment = comment.get("comments", {}).get("data", [])
            if parent_comment:
                parent_comment = parent_comment[0]
                comment_dict["parent_id"] = parent_comment.get("id")
                comment_dict["parent_name"] = parent_comment.get("from", {}).get("name")
            comments.append(comment_dict)
    df = pd.DataFrame(comments)
    return df, response.json()

def create_reply_dataframe(json_object, add_replies=False):
    # Initialize empty lists to store data
    post_id_list = []
    parent_comment_message_list = []
    comment_id_list = []
    reply_comment_message_list = []
    reply_created_time_list = []
    reply_id_list = []
    
    # Loop through each post in the json object
    for post in json_object:
        # Get the post ID
        post_id = post['id']
        
        try: # SH 2023-03-22 10:50 Added this 
            # Loop through each comment in the post
            for comment in post['comments']['data']:
                # Get the comment ID and message
                comment_id = comment['id']
                parent_comment_message = comment['message']
                
                # Check if the comment has any replies
                if add_replies == True:
                    # Loop through each reply to the comment
                    for reply in comment['comments']['data']:
                        if 'comments' in comment:
                            # Get the reply ID, message, and creation time
                            reply_id = reply['id']
                            reply_comment_message = reply['message']
                            reply_created_time = reply['created_time']
                            
                            # Add the data to the lists
                            post_id_list.append(post_id)
                            parent_comment_message_list.append(parent_comment_message)
                            comment_id_list.append(comment_id)
                            reply_comment_message_list.append(reply_comment_message)
                            reply_created_time_list.append(reply_created_time)
                            reply_id_list.append(reply_id)
                else:
                    # Add the data to the lists
                    post_id_list.append(post_id)
                    parent_comment_message_list.append(parent_comment_message)
                    comment_id_list.append(comment_id)
        except Exception  as error:
            # exc_type, exc_obj, tb = sys.exc_info()
            # f = tb.tb_frame
            # lineno = tb.tb_lineno
            # filename = f.f_code.co_filename
            # print("An error occurred on line", lineno, "in", filename, ":", error)
            pass
    
    # Create a dataframe from the lists
    if add_replies == True:
        df = pd.DataFrame({
            'post_id': post_id_list,
            'parent_comment_message': parent_comment_message_list,
            'comment_id': comment_id_list,
            'reply_comment_message': reply_comment_message_list,
            'reply_created_time': reply_created_time_list,
            'reply_id': reply_id_list
        })
    else:
        df = pd.DataFrame({
            'post_id': post_id_list,
            'parent_comment_message': parent_comment_message_list,
            'comment_id': comment_id_list,
        })
    return df

def merge_dataframes(comments_df, posts_df, replies_df, add_replies=False):
    # merge comments and posts dataframes on post_id
    merged_df = pd.merge(comments_df, posts_df, on='post_id', how='outer')
    # merge replies dataframe on comment_id
    merged_df = pd.merge(merged_df, replies_df, left_on='message_x', right_on='parent_comment_message', how='left')
    if add_replies == True:
        # rename columns
        merged_df = merged_df.rename(columns={
            'post_id_x': 'post_id',
            'created_time_x': 'comment_created_time',
            'created_time_y': 'post_created_time',
            'message_x': 'comment_message',
            'message_y': 'post_message',
            'parent_name_x': 'parent_name',
            'reply_comment_message': 'reply_message',
            'reply_created_time': 'reply_created_time',
            'reply_id': 'reply_id'
        })
        # drop unnecessary columns
        merged_df = merged_df.drop(columns=['parent_name', 'parent_id'])
        # reorder columns
        merged_df = merged_df[['post_id', 'post_message', 'post_created_time', 'comment_created_time', 'parent_comment_message',
                            'comment_id', 'reply_message', 'reply_created_time', 'reply_id']]
    else:
        # rename columns
        merged_df = merged_df.rename(columns={
            'post_id_x': 'post_id',
            'created_time_x': 'comment_created_time',
            'created_time_y': 'post_created_time',
            'message_x': 'comment_message',
            'message_y': 'post_message',
            'parent_name_x': 'parent_name',
        })
        # drop unnecessary columns
        merged_df = merged_df.drop(columns=['parent_name', 'parent_id'])
        # reorder columns
        merged_df = merged_df[['post_id', 'post_message', 'post_created_time', 'comment_created_time', 'parent_comment_message',
                            'comment_id']]
    return merged_df

def process_posts(df):
    """
    Return the unique non-null parent_comment_message values and the associated post_message values.
    """
    df = df[['parent_comment_message', 'post_message']].drop_duplicates()
    df = df[df['parent_comment_message'].notnull()]
    df = df[df['post_message'].notnull()]
    results = pd.DataFrame(
        df.apply(lambda row: f"You: {row['post_message']}\n\nMember: {row['parent_comment_message']}", axis=1).unique(),
        columns=['text'])
    return results


iteration = 1.11

# Get Facebook group posts
posts_data_dict[iteration] = get_facebook_posts(group_id, access_token)
posts_df_dict[iteration] = process_response(posts_data_dict[iteration])
comments_df_dict[iteration], comments_response_dict[iteration] = get_fb_comments(group_id, access_token)
replies_dict[iteration] = create_reply_dataframe(comments_response_dict[iteration]['data'], add_replies=0)
merged = merge_dataframes(comments_df_dict[iteration], posts_df_dict[iteration], replies_dict[iteration])

"""
Each row in this dataframe contains one comment (`parent_comment_message`) to a post (`post_message`). 
Some posts are repeated because they have multiple comments.
"""
merged

print(f"Number of unique posts: {len(merged['post_id'].unique())}")
print(f"Number of unique top-level comments: {len(merged['comment_id'].unique())}")

def process_posts(df_raw):
    """
    Return the unique non-null parent_comment_message values and the associated post_message values.
    """
    df = df_raw.copy()
    df = df[['parent_comment_message', 'post_message']].drop_duplicates()
    df = df[df['parent_comment_message'].notnull()]
    df = df[df['post_message'].notnull()]

    # Sort the dataframe by 'post_message' length in descending order
    df.sort_values(by='parent_comment_message', key=lambda x: x.str.len(), ascending=False, inplace=True)
    df.drop_duplicates(subset='post_message', keep='first', inplace=True)

    results = pd.DataFrame(
        df.apply(lambda row: f"YOU: {row['post_message']}\n\nMEMBER: {row['parent_comment_message']}", axis=1).unique(),
        columns=['text'])
    
    results['text'] = results['text'].str.replace('Amanda', 'Amy')
    results['text'] = results['text'].str.replace('amanda', 'amy')
    print(f'Shape of processed DataFrame containing Facebook group posts and comments: {results.shape}')
    return results

input_df = process_posts(merged)
input_df

from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chains import SequentialChain
import os
os.getenv('OPENAI_API_KEY')

def create_LLMChain(template, input_variables, output_key, llm=OpenAI(temperature=0, max_tokens=100)):
    """
    Create an LLMChain object.
    Parameters:
        - template (str): The template for the prompt, i.e. the value of the `template` 
            parameter in the PromptTemplate class.
        - input_variables (List[str]) 
        - output_key (str): The key of the output variable.
        - llm (OpenAI object): Default is OpenAI()

    Returns:
        - LLMChain object
    """
    prompt_template = PromptTemplate(
        template=template, input_variables=input_variables)
    chain = LLMChain(
        llm=llm, prompt=prompt_template, output_key=output_key)
    return chain, prompt_template.template

def analyze_text_sentiment(text, llm=OpenAI(temperature=0, max_tokens=200)):
    """
    Analyze the sentiment of a text.
    Parameters:
        - text (str): The text to analyze.
        - llm (OpenAI object): Default is OpenAI()

    Returns:
        - sentiment (str): The sentiment of the text.
    """
    
    # openai.api_key = os.getenv('api_openai_p')
    template_root = """
    You are the owner of a personal training business. You use a Facebook group to as a lead generation tool.
    You write posts in the group to engage with members and position yourself as \
    a coach who can help them achieve their fitness goals.
    You aim to respond quickly to comments by group members if they request information, \
    express a desire to improve their fitness, have health conditions or injuries, \
    or express dissatisfaction with their current fitness.
    Below, delimited by triple back ticks, is a post you wrote in the group and a comment from a member:, 
    """
    templates = {
        'sentiment': 'Determine the sentiment of the member comment as "positive", "neutral", or "negative".',
        'emotions': 'Determine the main emotion expressed in the member comment. Return your response as a single word.',
        'respond': 'Indicate whether you need to quickly respond to the message or not using "yes" or "no".',
    }
    template_end = 'If you are not sure of the answer, return "?"'
    chain_dict = {}
    prompt_dict = {}
    for template in templates:
        chain_dict[template], prompt_dict[template] = create_LLMChain(
            template_root+templates[template]+' ```{text}``` '+template_end, 
            input_variables=['text'], output_key=template,
            llm=llm)
    overall_chain = SequentialChain(
        chains = [chain for chain in chain_dict.values()], 
        input_variables = ['text' for chain in chain_dict.values()],
        output_variables = list(chain_dict.keys()), verbose=True
    )
    response_dict = overall_chain(text)
    return response_dict, prompt_dict

def batch_analyze_text_sentiment_from_df(messages_df, key='text'):
    response_dict = dict()
    prompt_dict = dict()
    messages_list = messages_df[key].tolist()
    failures = 0
    for iteration_id, message in enumerate(messages_list):
        # print(iteration_id, message)
        try:
            response_dict[iteration_id], prompt_dict[iteration_id] = analyze_text_sentiment(message)
        except Exception as error:
            exc_type, exc_obj, tb = sys.exc_info()
            f = tb.tb_frame
            lineno = tb.tb_lineno
            file = f.f_code.co_filename
            print("An error occurred on line", lineno, "in", file, ":", error)
            print('\t...Error making chatbot request')
            failures += 1
            if failures > 2:
                print('\t...Too many failures, stopping')
                break
    return response_dict, prompt_dict

def create_df_from_response(response):
    """
    Convert the response into a dataframe and strip white spaces at the start and end of text.
    """
    df = pd.DataFrame(response).transpose()
    for column in df.columns:
        df[column] = df[column].str.strip().str.replace('\n', ' ')
        df[column] = df[column].str.strip().str.replace('YOU:', '[YOU]')
        df[column] = df[column].str.strip().str.replace('MEMBER:', '[MEMBER]')
    return df

prompt_dict = dict()
message_dict = dict()
response_dict = dict()

iteration_id = 2

response_dict[iteration_id], prompt_dict[iteration_id] = batch_analyze_text_sentiment_from_df(input_df)

# Load previously pickled object
path = r'C:\Users\silvh\OneDrive\lighthouse\portfolio-projects\GPT 3.5-sentiment-analysis\outputs\raw\2023-07-01'
iteration = 2
prompt_dict = loadpickle('prompt_dict_2023-07-02_1903.sav', path)
response_dict = loadpickle('response_dict_2023-07-02_1903.sav', path)

results_dict = {iteration: create_df_from_response(response_dict[iteration])}
results_dict[iteration]

### Is the sentiment positive, negative, or neutral?
sentiment_hl_dict = pd.Series({
    0: 1,
    1: 1,
    2: -1,
    3: -1,
    4: 1,
    5: 1,
    6: 0,
    7: -1,
    8: 0,
    9: 1,
    10: 1,
    11: 1,
    12: 1,
    13: 0,
    14: 1,
    15: 1,
    16: 1,
    17: 1,
    18: 0
})
### Does the comment require a fast reply?
respond_hl_dict = pd.Series({
    0: 0,
    1: 0,
    2: 1,
    3: 1,
    4: 0,
    5: 0,
    6: 1,
    7: 1,
    8: 1, 
    9: 0,
    10: 0,
    11: 0,
    12: 0,
    13: 1,
    14: 0,
    15: 0,
    16: 0,
    17: 0,
    18: 0
})

## Note that this code block generates Plotly figures, which do not render in GitHub and don't get converted by nbconvert

import plotly.graph_objects as go
import pandas as pd
from plotly.subplots import make_subplots

def plot_class_proportions_int(sentiment_data, respond_data):
    # Count the occurrences of each class for sentiment_data
    sentiment_class_counts = sentiment_data.value_counts().sort_index()
    sentiment_total = sentiment_class_counts.sum()
    sentiment_class_proportions = sentiment_class_counts / sentiment_total * 100

    # Count the occurrences of each class for respond_data
    respond_class_counts = respond_data.value_counts().sort_index()
    respond_total = respond_class_counts.sum()
    respond_class_proportions = respond_class_counts / respond_total * 100

    # Create the figure with subplots
    fig = make_subplots(rows=1, cols=2)

    # Add the bar chart for sentiment_data
    fig.add_trace(go.Bar(x=sentiment_class_counts.index, y=sentiment_class_counts.values),
                  row=1, col=1)

    fig.update_xaxes(title_text="Sentiment", ticktext=["Negative", "Neutral", "Positive"], tickvals=[-1, 0, 1], row=1, col=1)
    fig.update_yaxes(title_text="Count", row=1, col=1)

    # Add the percentage labels to each bar in the Sentiment Class Proportions plot
    for i, proportion in enumerate(sentiment_class_proportions.values):
        fig.add_annotation(
            x=sentiment_class_proportions.index[i],
            y=sentiment_class_counts.values[i],
            text=f"{proportion:.2f}%",
            showarrow=False,
            font=dict(color="black"),
            xanchor="center",
            yanchor="bottom",
            row=1, col=1,
        )

    # Add the bar chart for respond_data
    fig.add_trace(go.Bar(x=respond_class_counts.index, y=respond_class_counts.values),
                  row=1, col=2)
    fig.update_xaxes(title_text="Requires fast response", ticktext=["No", "Yes"],  tickvals=[0, 1], row=1, col=2)
    fig.update_yaxes(title_text="Count", row=1, col=2)

    # Add the percentage labels to each bar in the Respond Class Proportions plot
    for i, proportion in enumerate(respond_class_proportions.values):
        fig.add_annotation(
            x=respond_class_proportions.index[i],
            y=respond_class_counts.values[i],
            text=f"{proportion:.2f}%",
            showarrow=False,
            font=dict(color="black"),
            xanchor="center",
            yanchor="bottom",
            row=1, col=2,
        )

    # Set the figure title and layout
    fig.update_layout(title="Most comments have positive sentiment and do not require a fast response", 
                      showlegend=False, title_x=0.5)

    # Show the figure
    fig.show()


plot_class_proportions_int(sentiment_hl_dict, respond_hl_dict)

import matplotlib.pyplot as plt
import numpy as np

def plot_class_proportions(sentiment_data, respond_data):
    # Count the occurrences of each class for sentiment_data
    sentiment_class_counts = sentiment_data.value_counts().sort_index()
    sentiment_total = sentiment_class_counts.sum()
    sentiment_class_proportions = sentiment_class_counts / sentiment_total * 100

    # Count the occurrences of each class for respond_data
    respond_class_counts = respond_data.value_counts().sort_index()
    respond_total = respond_class_counts.sum()
    respond_class_proportions = respond_class_counts / respond_total * 100

    # Create the figure with subplots
    fig, axs = plt.subplots(1, 2)

    # Bar chart for sentiment_data
    x_sentiment = np.array(sentiment_class_counts.index)
    y_sentiment = np.array(sentiment_class_counts.values)
    axs[0].bar(x_sentiment, y_sentiment)

    axs[0].set_xlabel("Sentiment")
    axs[0].set_ylabel("Count")
    axs[0].set_xticks([-1, 0, 1])
    axs[0].set_xticklabels(["Negative", "Neutral", "Positive"])

    # Add percentage labels to each bar in the Sentiment Class Proportions plot
    for i, proportion in enumerate(sentiment_class_proportions.values):
        axs[0].text(x_sentiment[i], y_sentiment[i], f"{proportion:.2f}%", ha="center", va="bottom", color="black")

    # Bar chart for respond_data
    x_respond = np.array(respond_class_counts.index)
    y_respond = np.array(respond_class_counts.values)
    axs[1].bar(x_respond, y_respond)

    axs[1].set_xlabel("Requires fast response")
    axs[1].set_ylabel("Count")
    axs[1].set_xticks([0, 1])
    axs[1].set_xticklabels(["No", "Yes"])

    # Add percentage labels to each bar in the Respond Class Proportions plot
    for i, proportion in enumerate(respond_class_proportions.values):
        axs[1].text(x_respond[i], y_respond[i], f"{proportion:.2f}%", ha="center", va="bottom", color="black")

    # Set the figure title
    fig.suptitle("Most comments have positive sentiment and do not require a fast response")

    # Adjust layout
    plt.tight_layout()

    # Show the figure
    plt.show()

plot_class_proportions(sentiment_hl_dict, respond_hl_dict)

from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt

def evaluate_GPT_results(results_df, GPT_label_column, human_labels):
    """
    Determine the accuracy of the GPT model by comparing its predictions to the human labels.

    Parameters:
        - results_df (pd.DataFrame): The dataframe containing the GPT predictions.
        - GPT_label_column (str): The column name containing the GPT predictions.
        - human_labels (pd.Series): The human labels.
    
    Returns:
        - accuracy (float): The accuracy of the GPT model.
        - DataFrame of GPT predictions and human labels.
        - confusion matrix (ConfusionMatrixDisplay): The confusion matrix of GPT predictions.

    """
    transformed_df = pd.DataFrame()
    if GPT_label_column == 'respond':
        transformed_df['GPT_label'] = results_df[GPT_label_column].apply(lambda x: 1 if x == 'Yes' else 0)
        cm_display_labels = ['No', 'Yes']
    else: 
        transformed_df['GPT_label'] = results_df[GPT_label_column].apply(lambda x: 1 if x == 'Positive' else -1 if x == 'Negative' else 0)
        cm_display_labels = ['Negative', 'Neutral', 'Positive']
    transformed_df['human_label'] = human_labels
    transformed_df['wrong_prediction'] = transformed_df['GPT_label'] != transformed_df['human_label']
    transformed_df['wrong_prediction'] = transformed_df['wrong_prediction'].apply(lambda x: 'Yes' if x else '')
    accuracy = accuracy_score(transformed_df['human_label'], transformed_df['GPT_label'])
    print(f'Accuracy of GPT model for "{GPT_label_column}": {accuracy}')
    fig, ax = plt.subplots(nrows=1, ncols=1)
    # ax = ax.flatten()
    cm = ConfusionMatrixDisplay.from_predictions(
        transformed_df['human_label'], transformed_df['GPT_label'], ax=ax,
        display_labels=cm_display_labels);
    ax.set_xticklabels(ax.get_xticklabels(), fontsize=10)
    ax.set_xlabel(ax.get_xlabel(), fontsize=14)
    ax.set_yticklabels(ax.get_yticklabels(), fontsize=10)
    ax.set_ylabel(ax.get_ylabel(), fontsize=14)
    return accuracy, transformed_df, fig

cm_dict = dict()
accuracy_dict = dict()
transformed_df_dict = dict()
  
accuracy_dict[iteration], transformed_df_dict[iteration], cm_dict[iteration] = evaluate_GPT_results(
    results_dict[iteration], 'sentiment', sentiment_hl_dict);

transformed_df_dict[iteration]

def create_df_from_response(response):
    """
    Convert the response into a dataframe and strip white spaces at the start and end of text.
    """
    df = pd.DataFrame(response).transpose()
    for column in df.columns:
        df[column] = df[column].str.strip().str.replace('\n', ' ')
        df[column] = df[column].str.strip().str.replace('YOU:', '[YOU]')
        df[column] = df[column].str.strip().str.replace('MEMBER:', '[MEMBER]')
    return df


results_dict = {iteration: create_df_from_response(response_dict[iteration])}
results_dict[iteration].loc[[2, 3, 6, 7, 18], ['text', 'sentiment']]

accuracy_dict[iteration], transformed_df_dict[iteration], cm_dict[iteration] = evaluate_GPT_results(
    results_dict[iteration], 'respond', respond_hl_dict);

transformed_df_dict[iteration]

results_dict[iteration].loc[17:17, ['text', 'respond']]

results_dict[iteration].loc[18:18, ['text', 'emotions']]

results_dict[iteration].loc[5:5, ['text', 'emotions']]