Journofile: A Personality Profiler of NYTimes Journalists

  • SupStat 

Contributed by Samara Bliss and Joseph Lee. They took NYC Data Science Academy 12 week full time Data Science Bootcamp pr… between Sept 23 to Dec 18, 2015. The post was based on their third class project(due at 6th week of the program).

Note: You’ll find snippets of our code in the following post. For the full code please go to the github repository.


Thanks to digital journalism, we have millions of opinions on practically every topic easily accessible at our fingertips. This revolutionary change in how we consume (and contribute to) news forces us to become critical thinkers, capable of evaluating the credibility of countless sources. But how can a reader efficiently evaluate an author’s background, style, themes, biases, quirks, etc. without reading his/her entire collective works and biography? Enter Journofile–our solution to this problem. Journofile is a tool written in Python programming language that grabs the New York Times articles written by any inputted author and, using Natural Language Processing, analyzes the texts for most frequently used words, sentiment polarity, sentiment subjectivity, and, most importantly, personality.


To begin, the articles from any given author are grabbed from the NYTimes using the openly accessible article search API. These queries return the URLs to the articles.

We then used the a combination of Python libraries Beautiful Soup and Goose Extractor to simultaneously scrape and parse the article contents. Beautiful soup was used primarily for exploring the tag structure of the HTML page, while Goose was the main packaged used for scraping. Below is a brief snippet of the Goose functions developed for this program. The extractWrapper function calls on the three previous functions to extract the URL text, the list of URLs, and the data of each text.

def extractArticle(url):
g = Goose()
article = g.extract(url=url)
return article.cleaned_text

def extractArticleList(datum):
archive = []
for ii in datum:
return archive

def extractDate(lst):
dates = []
for ii in lst:
match = re.search(r'\d{4}-\d{2}-\d{2}',str(ii))
return dates

def extractWrapper(name, number):
tmp = extractArticleList(x[0])
dates = extractDate(x[1])
raw = " ".join(tmp)
content = raw.encode('ascii', 'ignore')
return dates, tmp, content

Using the Natural Language Toolkit, we created a wrapper function that tokenizes and tags parts-of-speech to clean text, filters by tags so as to exclude conjunctives, prepositions, determiners, etc., and then casts the filtered text into a data frame that has been sorted by word frequency.

def castFreqDF(cleantext):

tokenized = word_tokenize(cleantext)
tags = nltk.pos_tag(tokenized)

def filteredtags(tags):
wantedTags = ["FW", "JJ", "JJR", "JJS", "NN", "NNP", "NNPS", "NNS"]
ftags = []
tagtag = []
for t in tags:
if t[1] in wantedTags:
return ftags , tagtag

x = filteredtags(tags)
fdist = FreqDist(x[0])
taglist = x[1]
vocab1 = fdist.keys()
tmp1 = []
tmp2 = []

for ii in fdist:
for jj in fdist:

s1 = pd.Series(tmp1)
s2 = pd.Series(tmp2)

d = {"Word":s1,
"Count" : s2}
df = pd.DataFrame(d)
return df.sort(["Count"], ascending = False, axis = 0)

In order to demonstrate our code, we’ll use NYTimes Opinion author, David Brooks. We’ll use his name as our passed argument.

author = "David Brooks"
x = extractWrapper(author, 20)

The Seaborn package was used for most of our visualizations.


In order to get the sentiment polarity and sentiment subjectivity of each text we used a library called TextBlob. The polarity is on a scale of -1 to 1 and the subjectivity is on a scale of 0 to 1.

def sentimentpolarity(sentiment_list):

tri_list = sentiment_list
dates = tri_list[0]
articles = tri_list[1]
sample = []
polarity = []
subjectivity = []
tmp_dates = []

for ii in articles:
for jj in articles:
blob = TextBlob(jj)
for kk in articles:
blob2 = TextBlob(kk)

for kk in range(len(articles)):

c1 = pd.Series(sample)
c2 = pd.Series(polarity)
c3 = pd.Series(subjectivity)
c4 = pd.Series(tmp_dates)

d = {"Sample":c1,
df = pd.DataFrame(d)

return df.sort('Date')


Lastly, in order to create an in-depth personality assessment of the author, we used a service powered by IBM Watson, the cognitive computing machine that famously won Jeopardy against Ken Jennings in 2011. The API is called Personality Insights and it uses the Linguistic Inquiry and Word Count (LIWC) program which compares the inputted text to internal dictionaries with psychologically-relevant tagging and percentages for each of its personality categories. The personality categories are based on needs, values, and the Big Five personality traits. To read more about the API take a look at this and to read more about LIWC try this. The API exists on the IBM cloud developer platform, Bluemix. We made a post request to the Personality Insights API, inputted the entire corpus of an author’s work, and the API returns the personality analysis as a JSON file. We then parsed the JSON output into a readable pandas data frame containing personality traits and corresponding percentages.

url = "https://gateway.watsonplatform.net/personality-insights/api"
username = "Your username"
password = "Your password

response = requests.post(url + "/v2/profile",
auth=(username, password),
headers = {"content-type": "text/plain"},

x = json.loads(response.text)
y = x["tree"]["children"]
trait = []
percentage = []
for ii in y:
for jj in ii["children"]:
for kk in jj["children"]:
#print kk["name"]
#print kk["percentage"]
if "children" in kk:
for zz in kk["children"]:
#print zz["id"]
#print zz["percentage"]
print " "

To visualize the personality assessment we used Bokeh, a new package designed by Continuum Analytics.




Again, please find our full code on our github.