Hugging Face's logo

Datasets:
chuxuan
/
REPRO-Bench

Tasks:
Image-Text-to-Text
Languages:
English
ArXiv:
Tags:
reproducibility
social-science
agents
Dataset card Files
xet
 Community
1
REPRO-Bench / 17 /replication_package /code /lib /data_helpers /clean_survey.py
anonymous-submission-acl2025's picture
anonymous-submission-acl2025
add 17
8a79f2e
Raw History Blame Contribute Delete
18.5 kB
import sys
import os
import pandas as pd
import random
import re
import string
from functools import reduce
import numpy as np
import math
from datetime import datetime, timedelta
from lib.data_helpers import data_utils
from lib.experiment_specs import study_config
from lib.utilities import codebook
from lib.utilities import serialize
from lib.data_helpers.confidential import Confidential
from lib.data_helpers.manual_changes import ManualChanges
from lib.data_helpers.builder_utils import BuilderUtils
random.seed(23555)
"""
Purpose: Cleans Qualtrics surveys based on their configs in study_config
Input:
- Survey Name only input survey names found in data/{study}/configurations/study_config
- input_dir: directory of raw file
- output_dir: directory of clean_master file
- remove_embedded: if True, removes the embedded data from a raw qualtrics survey
- test: bool - if True, keeps all banned email responses
- codebook: bool - if True, the qualtrics cleaner will update the master codebook. for check_survey.py, this is set to False, and for the main pipeline, this is set to true
- helper_paths : the dictionary specifies the absolute path locations of 'Manual Changes' an excel spreadsheet where specify
changes to the survey answers, and 'Testers' where we specify information for the PhoneAddictionTeam
{'ManualChanges':manual_changes_path, 'Testers':testers_path}
MainFunction: clean_survey
Output: Clean survey file
Note: DON'T MAKE ANY NEW VARS -- THEY WILL BE DELETED BECAUSE WE CROP ALL DATA BEFORE THE FIRST VAR AND ALL DATA AFTER THE LAST VAR
Note: all variables are converted to strings, and NaN will be coded as "nan"
"""
class CleanSurvey():
default_helper_paths = {"Intermediate": os.path.join("data", "external", "intermediate"),
"Confidential": os.path.join("data", "external", "dropbox_confidential")}
def __init__(self, survey_name: str, input_dir: str, output_dir: str,
remove_embedded: bool = True, test: bool = False, codebook_bool: bool = True,
helper_paths: dict = default_helper_paths):
self.survey_name = survey_name
self.open_date_time = study_config.surveys[survey_name]["Start"]
self.close_date_time = study_config.surveys[survey_name]["End"]
self.code = study_config.surveys[survey_name]["Code"]
self.raw_file_path = os.path.join(input_dir, survey_name + ".csv")
self.clean_file_path = os.path.join(output_dir, survey_name + ".csv")
self.intermediate_dir = helper_paths["Intermediate"]
self.confidential_dir = helper_paths["Confidential"]
self.testers = pd.read_excel(os.path.join(self.confidential_dir,"Testers.xlsm"), sheet_name="Testers")
self.timezones_path = os.path.join(self.intermediate_dir,"Timezones")
self.manual_changes_path = os.path.join(self.confidential_dir,"ManualChanges.xlsx")
self.pii_path = Confidential.id_file
self.remove_embedded = remove_embedded
self.test = test
self.codebook_bool = codebook_bool
def clean_survey(self):
raw_data_file = os.path.join(self.raw_file_path)
print(f"\n Processing {self.survey_name}")
df = pd.read_csv(raw_data_file, dtype=str)
if len(df)==0:
print(f"No Data in{self.survey_name}")
return pd.DataFrame()
print(f"obs before processing {len(df)-2}")
df = self._process_col_names(df)
df = self._process_col_values(df)
""" we know the qualtricts datetimes are in eastern, so we
adjust the qualtrics times to local using the timezones found in the PD data"""
df = self._process_datetimes(df)
df = self._filter_timeframe(df)
df = self._filter_emails(df)
df = self._validate_completes(df)
if self.survey_name in study_config.text_surveys:
df = self._reshape_text_survey(df)
df = ManualChanges.manual_clean(df, self.survey_name, self.manual_changes_path)
df.to_csv(self.clean_file_path, index=False)
return df
df = self._filter_duplicates(df)
df = ManualChanges.manual_clean(df, self.survey_name, self.manual_changes_path)
df = df.reset_index(drop=True)
Confidential.build_id_map(df,self.survey_name, self.pii_path)
Confidential.anonymize_cols(df)
if self.code is not None:
df = data_utils.add_survey_code(df, self.code)
#if self.test:
# self.clean_file_path = self.clean_file_path.replace(".csv", "TEST.csv")
df.to_csv(self.clean_file_path, index=False)
"""in prep for merge, remove embedded data. keep in csv exported above just for comparison"""
if self.remove_embedded:
df = self._remove_embedded_data(df)
print("Created {0} with {1} entries".format(self.survey_name, len(df.index)))
return df
def _process_col_names(self, df: pd.DataFrame):
df.columns = df.columns.str.replace(' ', '')
df.columns = df.columns.str.replace('_', '')
df = codebook.rename_vars(df)
if self.codebook_bool:
self._update_codebook(df)
df = df.iloc[2:, :]
df_dup = df.loc[:, df.columns.duplicated()]
if len(list(df_dup.columns)) > 0:
print(f" \t Duplicate Columns to delete: {df_dup.columns}")
df = df.loc[:, ~df.columns.duplicated()]
return df
def _process_col_values(self, df):
df = df.astype(str).applymap(lambda x: x.strip())
for p_col in ["PhoneNumber","PhoneNumberConfirm","FriendContact"]:
if p_col in df.columns.values:
df[p_col] = df[p_col].apply(lambda x: re.sub("[^0-9]", "", str(x)))
df[p_col] = df[p_col].apply(lambda x: "1"+x if len(x)==10 else x)
df[p_col] = df[p_col].apply(lambda x: x if len(x) == 11 else 'nan')
#silly bug
if self.survey_name == "Baseline":
print("\t dealing with dumb baseline bug to ensure appcode assertion passes")
print(f"\t Len before dropping sherry {len(df)}")
df = df.loc[df["MainEmail"]!="xy1087@nyu.edu"]
print(f"\t len after dropping sherry {len(df)}")
# ADD APPCODES to survey without appcode
if "AppCode" not in df.columns.values:
print("\t No AppCode in Survey")
# make the main email col in pii the raw email col in the survey w/o appcode
pii = serialize.open_pickle(self.pii_path).reset_index().rename(columns = {"index":"AppCode"})
email_col = study_config.surveys[self.survey_name]["RawEmailCol"]
pii = pii.loc[pii["MainEmail"] != "nan",["AppCode", "MainEmail"]].rename(columns = {"MainEmail":email_col})
df = df.merge(pii, on=email_col, how='left')
print("done merger")
for appcode_col in ["AppCode", "AppCodeConfirm"]:
if appcode_col in df.columns.values:
df = data_utils.add_A_to_appcode(df,appcode_col)
"If no appcode, assign 'UNASSIGNED_' + ResponseID as Appcode"
df.loc[df[appcode_col]=="nan", appcode_col] = 'UNASSIGNED_'+df["ResponseID"]
if "AppCode" not in df.columns:
print("AppCode not in df.columns. Anonymize with Response ID")
df["AppCode"] = 'UNASSIGNED_'+df["ResponseID"]
#Temptation Stratification for SurveyChecks
if self.survey_name =="Recruitment":
df["Age"] = df["Age"].astype(float)
df.loc[(df["Age"]>=18)&(df["Age"]<=34),"AgeStrat"] = "18-34"
df.loc[(df["Age"] >= 35) & (df["Age"] <= 50), "AgeStrat"] = "35-50"
df.loc[(df["Age"] > 50), "AgeStrat"] = "50+"
df["Age"] = df["Age"].fillna("nan").astype(str)
return df
def _process_datetimes(self,df):
df['SurveyStartEasternDatetime'] = pd.to_datetime(df['SurveyStartDatetime'], infer_datetime_format=True)
df['SurveyEndEasternDatetime'] = pd.to_datetime(df['SurveyEndDatetime'], infer_datetime_format=True)
df.loc[:, 'OpenEasternDateTime'] = self.open_date_time
df.loc[:, 'CloseEasternDateTime'] = self.close_date_time
# Create Local Datetime
try:
# Get the modal timezone for each user to adjust the easter survey times to local time of user
timezones = serialize.open_pickle(self.timezones_path)
df = df.merge(timezones, on = "AppCode", how = 'left')
for time_var in ['SurveyStartEasternDatetime','SurveyEndEasternDatetime','OpenEasternDateTime','CloseEasternDateTime']:
df[time_var.replace("Eastern","")]= df[time_var]+df["EastToLocal"]
#if we can't find timezone, let local timezone equal eastern timezone
df.loc[df[time_var.replace("Eastern","")].isnull(),time_var.replace("Eastern","")] = df[time_var]
df.loc[df["EastToLocal"].isnull(),"EastToLocal"] = timedelta(0)
except:
print("Could not merge status exporter likely because Appcode not in survey or because timezones file not in path")
df['SurveyStartDatetime'] = pd.to_datetime(df['SurveyStartDatetime'], infer_datetime_format=True)
df['SurveyEndDatetime'] = pd.to_datetime(df['SurveyEndDatetime'], infer_datetime_format=True)
return df
return df
"""for each possible email column, drop nan's, drop banned emails, keep last of duplicate"""
def _filter_emails(self, df):
print(f"obs before filtering tester emails {len(df)}")
other_email_cols = ['SchoolEmail', 'PreferEmail', 'RecipientEmail', "Email", "EmailConfirm", "Email.1"]
if not self.test:
for email_col in other_email_cols+["ParentEmail"]:
if email_col in list(df.columns.values):
df = df.loc[~df[email_col].isin(list(self.testers["Email"]))]
else:
print("Because self.test == True, all banned emails will be included!!")
# ensure the main email col is "MainEmail"
raw_email_col = study_config.surveys[self.survey_name]["RawEmailCol"]
if raw_email_col != "MainEmail":
# drop the current MainEmail Version, and create a new one using the raw email data
if "MainEmail" in df.columns:
df = df.drop(columns=["MainEmail"])
df = df.rename(columns={raw_email_col: "MainEmail"})
# drop other email cols
for col in other_email_cols:
if col in df.columns:
df = df.drop(columns=[col])
return df
# creates new variable "Complete" which indicates if the participant completed the survey, or the last column they filled in
def _validate_completes(self, df):
last_question = study_config.surveys[self.survey_name]["LastQuestion"]
# Assert the last question will not be filled by an anonymous code, regardless if the cell were empty
id_cols = list(study_config.id_cols.values())
assert last_question not in sum(id_cols, [])
question_index = list(df.columns).index(last_question)
survey_cols = list(df.columns)[:question_index+1:]
reverse_survey_cols = survey_cols[::-1]
complete_q = study_config.surveys[self.survey_name]["CompleteQuestion"]
df.loc[(df["Finished"] == 'True') & (df[complete_q] != 'nan'), "Complete"] = "Complete"
df.loc[df["Complete"] != 'Complete', "Complete"] = "UnfinishedOther"
# Find the last completed survey variable
df_dict = df.to_dict(orient = 'index')
for key, value in df_dict.copy().items():
if value["Complete"] == "Complete":
continue
else:
for col in reverse_survey_cols:
#exclude empty cols
if (value[col] != "nan"):
try:
#exclude cols that are automatically filled in
if "UNASSIGNED" not in str(value[col]):
df_dict[key]["Complete"] = col
break
except:
print("bug")
df = pd.DataFrame.from_dict(df_dict, orient = "index")
return df
def _filter_duplicates(self, df):
# filter out duplicates-- prioritize keeping complete obs, then the later obs
ranks = range(0,len(df.columns))
rank_of_cols = dict(zip(list(df.columns),ranks))
rank_of_cols["Complete"] = 9999999
df["CompleteRank"] = df["Complete"].apply(lambda x: rank_of_cols[x])
scratch_path = os.path.join(self.intermediate_dir, "Scratch")
for dup_col in ["MainEmail","AppCode"]:
if dup_col not in df.columns:
print(f"{self.survey_name} doesn't have an {dup_col} column")
else:
print(f"obs before dropping dups of {dup_col}: {len(df)}")
#sort obs by, appcode, how far they completed the survey, then time survey was started
df = df.sort_values(by = [dup_col,"CompleteRank","SurveyStartDatetime"])
#if dup_col == "MainEmail":
# dup = df[(df.duplicated(subset=["MainEmail"], keep=False)) & (df['MainEmail'] != "nan")]
# dup.to_csv(os.path.join(scratch_path, f"RecruitDups.csv"))
# mark all entries as duplicates, except for the last one
df = df.loc[(~df.duplicated(subset=[dup_col], keep='last')) | (df[dup_col] == "nan")]
#if dup_col == "MainEmail":
# df.to_csv(os.path.join(scratch_path, f"Keeps.csv"))
print(f"obs after dropping dups of {dup_col}: {len(df)}")
df = df.sort_values("SurveyStartDatetime")
return df
def _filter_timeframe(self, df):
print(f"obs before droppingpeople that began before survey start or ended after close {len(df)}")
if self.test == False:
df = df.loc[df['SurveyStartEasternDatetime'] >= df['OpenEasternDateTime']]
df = df.loc[df['SurveyEndEasternDatetime'] <= df['CloseEasternDateTime']]
return df
def _update_codebook(self, df):
codebook_dic = {}
for col in df.columns:
codebook_dic[col] = {
"VariableLabel": str(df.loc[0,col]),
"DataType": df.dtypes[col],
"PrefixEncoding": "Survey"
}
#Remove Timing Data from Codebook
timing_vars = ["Timing-ClickCount",
"Timing-PageSubmit",
"Timing-FirstClick",
"Timing-LastClick",
"BrowserMetaInfo"]
for varname, chars in codebook_dic.copy().items():
if len([x for x in timing_vars if x in chars["VariableLabel"].replace(" ","")]) > 0:
del codebook_dic[varname]
codebook.add_vardic_to_codebook(codebook_dic)
def _remove_embedded_data(self, df_f):
#first remove all the qualtrics tracker vars
unimportant_vars = [y for y in df_f if
any(x in y for x in ["FirstClick", "LastClick", "PageSubmit", "ClickCount"])]
df_f = df_f.drop(columns=unimportant_vars)
#then remove the embedded data
non_survey_vars_to_keep = study_config.main_cols + [f"{self.code}_{x}" for x in study_config.kept_survey_data]
for question_type in ["FirstQuestion", "LastQuestion"]:
if question_type in study_config.surveys[self.survey_name]:
last_question = study_config.surveys[self.survey_name]["Code"] + "_" + \
study_config.surveys[self.survey_name][question_type]
question_index = list(df_f.columns).index(last_question)
if question_type == "FirstQuestion":
keep_cols = list(set(non_survey_vars_to_keep + list(df_f.columns)[question_index:]))
else:
keep_cols = list(set(non_survey_vars_to_keep + list(df_f.columns)[:question_index + 1]))
df = df_f[[x for x in df_f.columns if x in keep_cols]]
# re order columns (put main cols in front and maintain order of survey columns
var_order = [x for x in non_survey_vars_to_keep if x in df_f.columns] + [x for x in df_f.columns if x not in non_survey_vars_to_keep]
kept_var_order = [x for x in var_order if x in df.columns]
df = df[kept_var_order]
# remove hyphens from df, but if var is prefixed, drop IF the non prefix var is df
"""
for var in df.columns:
if f"{self.code}_{self.code}" in var:
non_pref_var = var.replace(f'{self.code}_', '')
if var.replace(f"{self.code}_", "") in df.columns:
# if df[var] == df[var.replace(f"{self.code}_","")]:
if df.equals(df[[var, non_pref_var]]):
df = df.drop(columns=[var])
print(f"Dropping {var} b/c {non_pref_var} and identical")
else:
test = df[[var, non_pref_var]]
print(f"Keeping {var} b/c {var} != {non_pref_var}")
else:
print(f"Keeping {var} b/c unprefixed var still in df")
"""
return df
def _reshape_text_survey(self,df):
df["SurveyStartDate"] = df["SurveyStartDatetime"].dt.date
df = BuilderUtils.add_phase_label(raw_df = df,raw_df_date="SurveyStartDate", start_buffer=0, end_buffer=-1)
# Replace Values of phase with the start survey code
codes = [study_config.phases[x]["StartSurvey"]["Code"] for x in list(study_config.phases.keys())]
rename_dic = dict(zip(list(study_config.phases.keys()), codes))
df["Phase"] = df["Phase"].apply(lambda x: rename_dic[x] if x in rename_dic else x)
keep_vars =[study_config.surveys[self.survey_name]["CompleteQuestion"],"SurveyStartDatetime","SurveyEndDatetime","Complete"]
df_p = df.pivot_table(index=["AppCode"],
values=keep_vars,
columns=["Phase"],
aggfunc='first')
df_p.columns = [f'_{self.code}'.join(col[::-1]).strip() for col in df_p.columns.values]
df_p = df_p.reset_index()
return df_p