CS1026A代做、Python设计程序代写

日期：2024-11-23 10:44

CS1026A Fall 2024

Assignment 3: YouTube Emotions

Important Notes:

• Read the whole assignment document before you begin coding. This is a more

complex speciffcation than in past assignments and the examples and templates

near the end of this document will be important in solving this assignment.

• Assignments are to be completed individually. Use of tools to generate code,

working with another person, or copying from online resources are not allowed and

will result in a zero on this assignment regardless of how much was copied.

• A code template is given in Section 6 (on page 17) for your main.py and

emotions.py ffles. We highly recommend using these as a starting point for your

assignment. The code is also attached to the assignment on OWL.

Change Log:

• Nov. 4

th

: The comments.csv ffle attached to Brightspace had an unexpected

unicode character in one of the comments the changed the outcome of some of the

examples given in this document. comments.csv has now been corrected and the

examples in this document to match.

• Nov. 13

th

: A type-o was found in the example for make_report() in section 5. This has

now been corrected. The output shown at the end of the document in section 7 was

still correct. This change has no impact on the autograder (it was marking correctly).

1. Learning Outcomes

By completing this assignment, you will gain skills relating to

• Functions

• Dictionaries and lists

• Complex data structures

• Text processing

• Working with TSV and CSV ffles

• File input and output

• Exceptions in Python

• Simple module use

• Writing code that adheres to a given speciffcation

• Working with real world problem

2. Background

With the emergence of social media sites such as YouTube, Facebook, Reddit, Twitter (also

known as X), LinkedIn, and WhatsApp, more and more data is being produced and made

accessible online in a textual format. This textual data, such as YouTube comments,

Tweets, or Facebook posts, can be hard to process but is incredibly important for

organizations as it offers a current snapshot of the public’s emotions (affinity) or sentiment

about a topic at a current point in time. Having a live view of your customer’s current affinity

towards your products or the public’s view of your political campaign can be critical for

success.

Much work has been done towards the goal of creating large datasets of word affinity or

sentiment. One such effort is the National Research Council (NRC) Emotion Lexicon which

is a list of English words and their associations with eight basic emotions (anger, fear,

anticipation, trust, surprise, sadness, joy, and disgust) and two sentiments (negative and

positive).

Our goal in this assignment is to use a simpliffed version of the NRC Emotion Lexicon to

classify YouTube comments based on one of the following emotions anger, joy, fear, trust,

sadness, or anticipation. Based on the emotion contained in each comment for a particular

video we then want to generate a report that details the most common emotions YouTube

users have towards that video based on their comments.

3. Datasets

Your Python program will deal with two datasets, a keywords data set that contains a

simpliffed version of the NRC Emotion Lexicon (this dataset will remain the same for all

tests of your program) and a Comma-Separated Values (CSV) ffle that contains the

comments for a particular YouTube video (this dataset will change for each test of your

program).

3.1 Keywords Dataset (TSV File)

The keywords.tsv ffle attached to this assignment contains a simpliffed version of the NRC

Emotion Lexicon. This is a Tab-Separated Values (TSV) ffle in which each line of the ffle

contains a single word and its emotional classiffcation based on six emotions (anger, joy,

fear, trust, sadness, and anticipation). Each word in the ffle may be classiffed as having one

or more emotions. The following is an example of the ffrst 10 lines of this ffle where tab (\t) characters are

represented by arrows (→):

abacus→0→0→0→1→0→0

abandon→0→0→1→0→1→0

abandoned→1→0→1→0→1→0

abandonment→1→0→1→0→1→0

abbot→0→0→0→1→0→0

abduction→0→0→1→0→1→0

abhor→1→0→1→0→0→0

abhorrent→1→0→1→0→0→0

abolish→1→0→0→0→0→0

abominable→0→0→1→0→0→0

Each line starts with a keyword and is followed by a score (0 or 1) for each emotion in this

order: anger, joy, fear, trust, sadness, and anticipation. If a 1 is present it means that

keyword is related to that emotion. If a 0 is present the keyword is unrelated to that

emotion.

For example, according to the above the word “abacus” is related to the emotion of trust

and no other emotions. The word “abandon” is related to the emotions fear and sadness

and no other emotions.

All words in the dataset will be related to at least one emotion. This ffle’s contents will

remain the same for all tests but may be given a different fflename based on the users input

(e.g. it could be named keys.tsv or words.tsv rather than keywords.tsv).

3.2 Comments Dataset (CSV File)

The user will provide a Comma-Separated Values (CSV) ffle that contains a set of YouTube

comments for a particular video. The name of this ffle will change based on the user’s input

but will always end in .csv and have the same format.

The following is an example of a possible line from this ffle (the ffle may contain one or

more lines). Note that this document wraps the line on to multiple lines but in the ffle this is

one line ended by a line break (\n):

2,PixelPioneer24,brazil,The excavation scenes in the movie were

excellent but the unnecessary derision of the hero's motives seemed

unfair. His eventuality of success was not adequately showcased. Each line of this ffle will contain four values separated by a single comma character (,). The

values will always be in the following order:

Comment ID, Username, Country, Comment Text

Comment ID is a unique positive integer identiffer for the comment. Username is the

username of the user who posted the comment. Country is the user’s home country, and

comment text is the text the of the comment posted by the user.

No value will contain a line break or a comma character. The capitalization of country

names could be different for each line even if it is for the same country, but the country will

always be spelled the same.

Space characters will only occur in the comment text or country name.

4. Tasks

In this assignment, you will write two Python ffles, emotions.py and main.py, that will

attempt to determine the most common emotion expressed in a YoutTube video’s

comments. You will create a number of functions (as speciffed in the Functional

Speciffcation in Section 5) that will perform simple sentiment analysis on the YouTube

comments.

To accomplish this, you will need to do the following:

1. Accept input from the user: The user will specify the ffle names of the keywords

and comments data sets as well as the name of the report ffle your program will

create. The user will also input the name of the country they wish to fflter the

comments by.

2. Read. Your program will read in the keyword and comments datasets and store

them in the formats described in the functional speciffcation (in Section 5).

3. Clean. The text of the comments will be cleaned to remove any punctuation and

convert them to all lowercase letters.

4. Determine Emotion. You will use the keyword’s dataset to determine the overall

emotion expressed in each comment.

5. Generate Report. Based on your analysis of each comment, you will create a report

ffle that contains a summary of the most common emotion expressed as well as

how common each emotion was (as speciffed in Section 5). Additionally, you must follow the functional speciffcation presented in Section 5 and the

rules and requirements in Section 8.

5. Functional Speciffcation

5.1 emotions.py

The functions described in this section should be present in your emotions.py ffle and must

be used in some way in your program to read, clean, process, analyze, or report on the

comments in the given dataset. Each function and its parameters must have the same

name and spelling as speciffed below:

clean_text(comment)

This function should have one parameter, comment, which is a string that contains the

text of a single comment from the comments dataset. The function should clean this

text by replacing any characters that are not letters (A to Z) and replacing them with

space characters. It should also convert the comment’s text to all lower case.

This function should return the cleaned text as a string.

Example:

clean_text("This4is-an example. It's a b*t silly.")

will result in this output:

this is an example it s a b t silly

make_keyword_dict(keyword_file_name)

This function should read the Tab-Separated Values (TSV) keywords ffle as described in

Section 3.1. keyword_ffle_name is a string containing the name of the keywords ffle.

This function can safely assume that this ffle exists, is in the current working directory,

and is properly formatted. Checks on the ffle’s existence will be done in the main.py ffle

described later in this document.

The function should return a dictionary with keys for each word in the ffle and the values

of this dictionary should be a new dictionary for each keyword that contains a value for

each emotion (anger, joy, fear, trust, sadness, and anticipation). Example:

Assuming that keywords.tsv contains the following three lines (where → is a tab

character):

abacus→0→0→0→1→0→0

abandon→0→0→1→0→1→0

abandoned→1→0→1→0→1→0

then calling

make_keyword_dict("keywords.tsv")

should result in the following nested dictionary data structure:

{'abacus': {'anger': 0,

'joy': 0,

'fear': 0,

'trust': 1,

'sadness': 0,

'anticipation': 0},

'abandon': {'anger': 0,

'joy': 0,

'fear': 1,

'trust': 0,

'sadness': 1,

'anticipation': 0},

'abandoned': {'anger': 1,

'joy': 0,

'fear': 1,

'trust': 0,

'sadness': 1,

'anticipation': 0}

} Note that to pass the Gradescope tests this function must return a dictionary and not

another collection such as a list, the keyword keys must be spelled exactly as listed in

keywords.tsv, and the emotions must be spelled correctly and in lower case.

Hint: You may find a number of the Python string methods helpful when creating this

function.

make_comments_list(filter_country, comments_file_name)

This function should read the Comma-Separated Values (CSV) file as described in

Section 3.2. comments_file_name is a string containing the name of the CSV file and

filter_country is a string containing either a country name or the string “all”. This

function should read the CSV file and return a list containing only comments for the

given country listed in filter_country (or all countries if the string “all” is given).

The list should contain one element for each comment in the file that matches the

country in the filter (or all comments if “all” is given). Each element in the list should be a

dictionary that contains a key for the Comment ID, Username, Country and Comment

Text. The keys should be named 'comment_id', 'username', 'country', and 'text'

respectively.

The comment text should be stripped of any leading and trailing whitespace.

Example 1:

Assuming that comments.csv only contains the following two lines (note that the line is

wrapped in this document and in the .csv file this is only two lines):

1,RetroRealm77,united states,I was a bit disappointed with the

film's portrayal of childhood heroism. It felt like the classic

elements were just concealed under layers of unnecessary savagery

and violence.

2,PixelPioneer24,brazil,The excavation scenes in the movie were

excellent but the unnecessary derision of the hero's motives seemed

unfair. His eventuality of success was not adequately showcased.

then calling

make_comments_list("all", "comments.csv")

should result in the following nested list and dictionary data structure: [ {'comment_id': 1,

'username': 'RetroRealm77',

'country': 'united states',

'text': 'I was a bit disappointed with the film's portrayal of

childhood heroism. It felt like the classic elements were just

concealed under layers of unnecessary savagery and violence.'},

{'comment_id': 2,

'username': 'PixelPioneer24',

'country': 'brazil',

'text': 'The excavation scenes in the movie were excellent but

the unnecessary derision of the hero's motives seemed unfair. His

eventuality of success was not adequately showcased.'} ]

Example 2:

Given the same contents of comments.csv as in Example 1, if the following function call

with the country name brazil was made:

make_comments_list("brazil", "comments.csv")

then the only element in the returned list would be:

[ {'comment_id': 2,

'username': 'PixelPioneer24',

'country': 'brazil',

'text': 'The excavation scenes in the movie were excellent but

the unnecessary derision of the hero's motives seemed unfair. His

eventuality of success was not adequately showcased.'} ]

Example 3:

Given the same contents of comments.csv as in Example 1, if the function was called

with a country name that was not present in the file such as:

make_comments_list("not a real country", "comments.csv")

then the resulting list would be empty:

[]

Note that to pass the Gradescope tests this function must return a list and not another

collection such as a set or dictionary, the values of each list element must be a

dictionary, and the keys used in that dictionary must match the spelling and lowercase

capitalization given in this section.

classify_comment_emotion(comment, keywords)

This function takes the text of a comment and the keywords dictionary created by the

make_keyword_dict function as parameters and classifies the comment as one of the

possible emotions (anger, joy, fear, trust, sadness, and anticipation), returning the

emotion as a string.

A comment is classified by first cleaning the text (using the clean_text function) and

then checking each word in the comment against the keywords dictionary. A total for

each possible emotion should be kept with each word in the comment matching a

keyword adding to the totals (based on the values in the keywords dictionary).

Example:

For the comment:

The excavation scenes in the movie were excellent but the

unnecessary derision of the hero's motives seemed unfair. His

eventuality of success was not adequately showcased.

the text should be first cleaned using clean_text to get:

the excavation scenes in the movie were excellent but the

unnecessary derision of the hero s motives seemed unfair his

eventuality of success was not adequately showcased then each word should be checked against the keywords dictionary and the totals for

each emotion kept. Words not matching any words in the dictionary (shown in black

above) do not add to the scores. For example, using the full keywords.tsv dataset the

words shown in blue above have matches in the keyword dataset and would result in

the following totals:

Word anger joy fear trust sadness anticipation

excavation 0 0 0 0 0 1

excellent 0 1 0 1 0 0

derision 1 0 0 0 0 0

hero 0 1 0 1 0 1

unfair 1 0 0 0 1 0

eventuality 0 0 1 0 0 1

success 0 1 0 0 0 1

Total: 2 3 1 2 1 4

Therefore, this comment would be classified as having the emotion of anticipation and

the string “anticipation” should be returned by the function as it as the highest score.

In the event of a tie, the emotions should be given priority in this order: 1) anger, 2) joy, 3)

fear, 4) trust, 5) sadness, and 6) anticipation.

Hint: You may find the string split method useful for looping through words rather than

characters.

make_report(comment_list, keywords, report_filename)

This function takes the comment_list (created by the make_comments_list function),

the keywords dictionary (created by the make_keyword_dict function), and a string

containing the file name of the report to generate (report_filename) as parameters.

A new file should be created with the file name in report_filename and it should contain

the name of the most common emotion classification in the comment_list dataset as

well as a count of the number of comments classified as each emotion. In the event of a

tie the emotions should be given priority in this order: 1) anger, 2) joy, 3) fear, 4) trust, 5)

sadness, and 6) anticipation.

The format of the report should match the following example which is based on the

attached comments.csv and keywords.tsv with a country filter of “all”:

Most common emotion: anger

Emotion Totals

anger: 5 (33.33%)

joy: 2 (13.33%)

fear: 1 (6.67%)

trust: 3 (20.0%)

sadness: 3 (20.0%)

anticipation: 1 (6.67%)

The emotion totals should occur in the same order (regardless of the counts) but the

values would be different depending on the comment_list and keywords dictionary

passed to the function.

All percentages should be rounded to two digits and all six emotions should always be

listed even if their count is zero. Important: in your report file each percentage must be

written with one or two decimal places. A value such as 20.000% or 6.6700% would be

wrong even though it is technically rounded as there are too many decimal places. Your

output must be formatted exactly as shown in the example above including the spacing

and line breaks.

Return

The function should return the name of the most common emotion; in this example it

would be “anger”.

Exception

In the event that the comment_list contains no comments (i.e. it is an empty list), the

function should raise a RuntimeError containing the text “No comments in dataset!”.

Reminder: The report should be saved to a file and not output to the screen or returned

by the function. Only the name of the most common emotion should be returned.

5.2 main.py

The program in main.py should ask the user for the file names of the keyword file and

comments file that the data will be read from, as well as the name of the report file that will

be created. It must use the functions defined in the emotions.py file to perform the tasks

described in Section 4 and write the final report.

Your main.py file must contain the following two functions (ask_user_for_input and main)

as specified:

ask_user_for_input()

This function takes no parameters but asks the user to input the file names of the

keywords TSV file, the comments CSV file, the country to filter by, and the file name of the

report to be generated. These three filenames and the country name are returned in a

tuple in this order: 1) keyword filename, 2) comment fflename, 3) country name

(converted to lower case), and 4) report filename.

Example (of valid input):

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): Canada

Input the name of the report file (ending in .txt): report.txt

User input is shown in green and input prompts in black. Note that the filenames and

country are based on the user’s input and can not be hardcoded to one set value. This

means that the filenames could be different depending on the values input by the user.

In this case the following tuple would be returned:

('keywords.tsv', 'comments.csv', 'canada', 'report.txt')

Note that the country name was converted to all lowercase.

Exceptions

Your ask_user_for_input() method must complete the following checks on the user input.

If the input does not pass a check, an Exception should be raised causing the function to

exit immediately. Exceptions should be raised as soon as the invalid input is given. For example, if the

keyword file does not exist, an exception should be raised before asking the user to input

the comments file name.

Check 1: File Extension

For each of the three filenames, if the user inputs a filename ending in the wrong file

extension (.csv, .tsv, or .txt) the function should raise a ValueError exception with a

message stating that the file extension is incorrect such as “Keyword file does not end in

.tsv!”. The text of this message must be exactly the following for each file:

• Keyword File: “Keyword file does not end in .tsv!”

• Comments File: “Comments file does not end in .csv!”

• Report File: “Report file does not end in .txt!”

Check 2: Files Exist

For the keyword and comment files you must check if the file exists using the

os.path.exists function. If it does not, your function must raise a IOError exception with

text explaining that the function does not exist. The message should have the text “<file

name> does not exist!” where <file name> is replaced with the filename such as

“keywords.tsv does not exist!", where keywords.tsv is the missing file.

For the report file, if the file already exists, an IOError should be raised with text stating

that “<file name> already exists!” where <file name> is the name of the report file. For

example “report.txt already exists!” where the report file is named report.txt. This is to

help prevent accidentally overwriting any files.

Check 3: Valid Country

Lastly you must check that the country input is either “all” or one of the following

countries: 'bangladesh', 'brazil', 'canada', 'china', 'egypt', 'france', 'germany', 'india', 'iran',

'japan', 'mexico', 'nigeria', 'pakistan', 'russia', 'south korea', 'turkey', 'united kingdom', or

'united states'. If any other country or word is input, a ValueError should be raised with

the text “<country> is not a valid country to filter by!” where <country> is the country the

user input. This subset of countries was chosen as they tend to occur in the datasets, we are using

more than others. In more realistic scenario you would likely want to include all valid

country names in this list, but this assignment limit to the above-mentioned countries.

Keep in mind that this only limits the countries a user can filter by, it does not limit what

country names can occur in the dataset.

main()

This function handles calling the other functions in main.py and emotions.py to perform

the tasks listed in Section 3. It should check for any exceptions being raised by the

ask_user_for_input function, output the error message contained in the exception (this

can be done by simply printing the exception with print()), and ask the user to input the

values again if any exception is raised.

Once valid input has been received, it should call the functions from emotions.py

required to analyze the comments and generate the report.

Lastly it should output to the screen the most common emotion in the comment data set.

This should be displayed as “Most common emotion is: <emotion name>” where emotion

name is the name of the emotion such as “Most common emotion is: anger” if the

emotion is anger.

If the make_report function raises a RuntimeError exception (e.g. the comment list was

empty), it should output the message contained in that error.

Example 1:

For the values in the attached keywords.tsv and comments.csv files:

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): all

Input the name of the report file (ending in .txt): report.txt

Most common emotion is: anger

User input is shown in green and the contents of the outputted report.txt file is:

Most common emotion: anger

Emotion Totals

anger: 5 (33.33%) joy: 2 (13.33%)

fear: 1 (6.67%)

trust: 3 (20.0%)

sadness: 3 (20.0%)

anticipation: 1 (6.67%)

Example 2:

For the same values in keywords.tsv and comments.csv but a country of “Canada”:

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): Canada

Input the name of the report file (ending in .txt): report_cad.txt

Most common emotion is: sadness

And the contents of report_cad.txt would be:

Most common emotion: sadness

Emotion Totals

anger: 1 (16.67%)

joy: 0 (0.0%)

fear: 0 (0.0%)

trust: 2 (33.33%)

sadness: 3 (50.0%)

anticipation: 0 (0.0%)

Example 3:

In this example invalid inputs are given, and the user is asked to input them again.

Input keyword file (ending in .tsv): not_a_real_file.tsv

Error: not_a_real_file.tsv does not exist!

Input keyword file (ending in .tsv): real_file_wrong_extension.txt

Error: Keyword file does not end in .tsv!

Input keyword file (ending in .tsv): keys.tsv

Input comment file (ending in .csv): not_a_real_file.csv

Error: not_a_real_file.csv does not exist!  

Input keyword file (ending in .tsv): keys.tsv

Input comment file (ending in .csv): bad_file_extension.tsv

Error: Comment file does not end in .csv!

Input keyword file (ending in .tsv): keys.tsv

Input comment file (ending in .csv): c.csv

Input a country to analyze (or "all" for all countries): Duck

Error: duck is not a valid country to filter by!

Input keyword file (ending in .tsv): keys.tsv

Input comment file (ending in .csv): c.csv

Input a country to analyze (or "all" for all countries): Belgium

Error: belgium is not a valid country to filter by!

Input keyword file (ending in .tsv): keys.tsv

Input comment file (ending in .csv): c.csv

Input a country to analyze (or "all" for all countries): FrAnCe

Input the name of the report file (ending in .txt): report.txt

Error: report.txt exists, the report file can not already exist!

Input keyword file (ending in .tsv): keys.tsv

Input comment file (ending in .csv): c.csv

Input a country to analyze (or "all" for all countries): FrAnCe

Input the name of the report file (ending in .txt): report_france.txt

Error: No comments in dataset!

Note that the above is one run of the program. It should keep asking for input again if an

exception occurs in the ask_user_for_input function. Also note that in this example,

keys.tsv and c.csv are valid files that exist and the file report.txt already exists. “Belgium”

is not in the list of valid countries so it is rejected and “FrAnCe” is accepted despite it’s

odd capitalization as the ask_user_for_input function should convert it to lowercase.

In this example, the c.csv file contained no comments for France, so the exception “No

comments in dataset!” was raised by make_report function.

6. Templates

This section gives some starter code you should use in your program. You may not alter the

names of any function or the parameters the functions take (this includes adding or

removing parameters). You may not import any libraries or modules not included in the

template code and all code you add should be inside a function (adding code outside of a

function may cause the Gradescope tests to fail). You may add additional helper functions

as needed.

emotions.py

# add a comment here with your name, email, and student number

# you can not add any import lines to this file

EMOTIONS = ['anger', 'joy', 'fear', 'trust', 'sadness', 'anticipation']

def clean_text(comment):

# add your code here and remove the pass keyword on the next line

pass

def make_keyword_dict(keyword_file_name):

# add your code here and remove the pass keyword on the next line

pass

def classify_comment_emotion(comment, keywords):

# add your code here and remove the pass keyword on the next line

pass

def make_comments_list(filter_country, comments_file_name):

# add your code here and remove the pass keyword on the next line

pass

def make_report(comment_list, keywords, report_filename):

# add your code here and remove the pass keyword on the next line

pass

main.py

# add a comment here with your name, email, and student number.

# do not add any additional import lines to this file.

import os.path

from emotions import *  

VALID_COUNTRIES = ['bangladesh', 'brazil', 'canada', 'china', 'egypt',

'france', 'germany', 'india', 'iran', 'japan', 'mexico',

'nigeria', 'pakistan', 'russia', 'south korea', 'turkey',

'united kingdom', 'united states']

def ask_user_for_input():

# add your code here and remove the pass keyword on the next line

pass

def main():

# add your code here and remove the pass keyword on the next line

pass

if __name__ == "__main__":

main()

Note About Imports

It is important to import the files in the correct order and from the correct files. Main.py

should import emotions.py as shown in the template above and not the other way around.

7. Extra Example

The files keywords.tsv and comments.csv should be attached to this assignment on

OWL. The result of running them with the following countries is given below:

Example 1: Country of “All”

Input/Output:

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): all

Input the name of the report file (ending in .txt): my_report.txt

Most common emotion is: anger

Contents of my_report.txt: Most common emotion: anger

Emotion Totals

anger: 5 (33.33%)

joy: 2 (13.33%)

fear: 1 (6.67%)

trust: 3 (20.0%)

sadness: 3 (20.0%)

anticipation: 1 (6.67%)

Example 2: Country of “brazil”

Input/Output:

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): brazil

Input the name of the report file (ending in .txt): report_brazil.txt

Most common emotion is: fear

Contents of report_brazil.txt:

Most common emotion: fear

Emotion Totals

anger: 0 (0.0%)

joy: 0 (0.0%)

fear: 1 (50.0%)

trust: 0 (0.0%)

sadness: 0 (0.0%)

anticipation: 1 (50.0%)

Example 3: Country of “germany” (there are no comments for this country in the data set)

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): germany

Input the name of the report file (ending in .txt): report.txt

Error: No comments in dataset!

Example 4: Invalid Inputs (these files do not exist or have the wrong extension)

Input keyword file (ending in .tsv): badfile.pizza

Error: Keyword file does not end in .tsv!

Input keyword file (ending in .tsv): this_file_does_not_exist.tsv

Error: this_file_does_not_exist.tsv does not exist!

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): badcsvfile.duck

Error: Comment file does not end in .csv!

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): not_a_real_csv_file.csv

Error: not_a_real_csv_file.csv does not exist!

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): not_a_real_country

Error: not_a_real_country is not a valid country to filter by!

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): JaPaN

Input the name of the report file (ending in .txt): badreportfile.exe

Error: Report file does not end with .txt!

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): JAPAN

Input the name of the report file (ending in .txt): already_exists.txt

Error: already_exists.txt exists, the report file can not already exist!

Input keyword file (ending in .tsv): keywords.tsv

Input comment file (ending in .csv): comments.csv

Input a country to analyze (or "all" for all countries): jApAn

Input the name of the report file (ending in .txt): new_report_file.txt

Most common emotion is: anger

8. Non-Functional Specification

In addition to the other tasks and specifications given in this document, your program must

also fulfill the following requirements:

1. Your code must be written for Python 3.10 or newer.

2. You may not use any modules or third-party libraries not described in this

document. Standard built-in functions such as the String, file, and math functions

are fine. You should not have to import anything other than your emotions.py and

the os.path module. TAs may manually remove marks from your Gradescope test if

you violate this rule.

3. You must document your code with brief comments. Each file should contain a

comment at the top of the file with your name, western e-mail, student number, and

a brief description of what is contained in that file. At least one comment should

also be given for each function that describes its purpose, parameters, and values

returned. You should also include any additional comments to document any lines

that may be unclear to the reader.

4. Your program must be efficient and terminate within a reasonable time limit. All

gradescope test cases (including any hidden cases) must terminate within the

autograder’s time limit.

5. Assignments are to be done individually and must be your own original work. You

may not show or otherwise share your code for this assignment with others or use

tools to generate your code for you. Software will be used to detect academic

dishonesty (cheating). If you have any questions about what is or is not academic

dishonesty, please consult the document on academic dishonesty and ask any

questions to your course instructor before submitting this assignment.

6. You must follow Python style and coding conventions and good programming

techniques, for example:

a. Meaningful variable and function names.

b. Use a consistent convention for naming variables, constants, and functions

(snake case is recommended).

c. Readability: indentation, white space, consistency.

7. All of your code should be contained in the files main.py and emotions.py. Only

submit these files and no others and ensure the filenames match exactly. It is your

responsibility to ensure you have submitted the correct files.

8. All function names and outputs should follow the specifications given in this

document exactly. Not following the specifications may lead to test cases failing. It is your responsibility to ensure you have followed them correctly and your tests are

passing.

9. Hardcoding or any other attempt to fool Gradescope’s autograder will result in a

zero grade for that test being manually assigned and possibly additional penalties. If

you have any doubts about what is or is not hardcoding, please ask your instructor

by posting to the course forums.

10. Frequently backup your work remotely (e.g. using OneDrive) in a way that is secure

and private. No extension will be given for lost or corrupted files or submitting

incorrect files.

9. Marking and Submission

9.1 Submission

You must submit the 2 files (main.py and emotions.py) to the Assignment 3 submission

page on Gradescope. There are several tests that will automatically run when you upload

your files. The result of each test with be displayed to you, but not necessarily the exact

details of the test. It is your responsibility to ensure all tests pass before the

assignment due date.

It is recommended that you create your own test cases to check that the code is working

properly for a multitude of different scenarios (some example datasets have been provided

for you with this document on OWL).

Assignments will not be accepted by email or by any other form other than a Gradescope

submission.

9.2 Marking

The assignment will be marked as a combination of your auto-graded tests (both visible

and hidden tests) and manual grading of your code logic, comments, formatting, style, etc.

Marks will be deducted for failing to follow any of the specifications in this document

(both functional and nonfunctional), not documenting your code with comments, using

poor formatting or style, hardcoding, or naming your files incorrectly.

Marking Scheme:

• Autograded Tests: 24.5 points

• Header comment including your name, student ID, course info, creation date, and

description of file: 1.5 points

• Descriptive in-line comments throughout code: 1 point

• Meaningful variable names: 1 point

Total: 28 points

9.3 Late Submissions

Late assignments will only be accepted up to 3 days late and only if you have enough late

coupons remaining (at least one for each day late). If you submit one day late, you will need

to use 1 late coupon. 2 days late, 2 late coupons. And 3 days late, 3 late coupons. If you

have insufficient late coupons remaining or submit more than 3 days late, you will receive a

zero grade on this assignment.

It is your responsibility to track your late coupon use. Any values shown on OWL should be

considered an estimate and may not be accurate or up to date.

Unlimited resubmissions are allowed, but the late penalty will be determined by the

date/time of your most recent (last) resubmission. This means if you resubmit past the

deadline, your assignment will be considered late.