Opengetpathlocalesjson wt as fp dumplocales fp

open(get_path("locales.json"), "wt") as fp:
dump(locales, fp, indent=2, sort_keys= True )
print("==> Done generating locales file.")
ex0_gen_locales()
ex0_gen_soln(force= False )
### END HIDDEN TESTS
def ex0_random_value():
from random import random, randint, choice
from numpy import nan
from problem_utils import ex0_random_date, ex0_random_string
options = [randint(-100, 100) # int
, ex0_random_string(randint(1, 10)) # string
, ex0_random_date(), # date
'', # implicit NaN
nan # explicit NaN
]
return choice(options)
def ex0_get_locales(filename=get_path("locales.json")):
from json import load
with open(filename, "rt") as fp:
locales = load(fp)
return locales
def ex0_gen_row(locales, num_dummies=0):
from datetime import datetime
from random import choice, random, randint
from numpy import nan
from problem_utils import ex0_random_date
country = choice(list(locales.keys()))
province = nan if random() <= 0.1 else choice(locales[country])
confirmed = 0 if random() <= 0.1 else randint(1, 100000)
last_updated = ex0_random_date()
if num_dummies:
dummy_vals = tuple([ex0_random_value() for _ in range(num_dummies)])
else :
dummy_vals = ()

11/1/2020 main
2/pmt2-sample-solutions (1)/midterm2/problem18/problem18.html 14/59
return (country, province, confirmed, last_updated, *dummy_vals)
def ex0_gen_df():
from random import randint, random
from pandas import DataFrame
from problem_utils import ex0_random_string
locales = ex0_get_locales()
# Generate random columns, which the student should ignore
num_dummy_cols = randint(1, 4)
dummy_cols = []
while len(dummy_cols) != num_dummy_cols:
dummy_cols = list({ex0_random_string(5) for _ in range(num_dummy_cols
)})
# Generate a bunch of random rows
num_trials = randint(10, 50)
rows = [ex0_gen_row(locales, num_dummy_cols) for _ in range(num_trials)]
# Remove any initial duplicates
rows = sorted(rows, key= lambda x: repr(x))
rows_soln = [rows[0]]
for r in rows[1:]:
if repr(r) != repr(rows_soln[-1]):
rows_soln.append(r)
# Construct the solution tibble
cols_in = ["Country/Region" if random() < 0.75 else "Country_Region",
"Province/State" if random() < 0.75 else "Province_State",
"Confirmed",
"Last Update" if random() < 0.75 else "Last_Update"]
cols_out = ["Country/Region", "Province/State", "Confirmed", "Last Update"
]
df_soln = DataFrame(rows_soln, columns=cols_out + dummy_cols)[cols_out] \
.rename(columns={"Last Update": "Timestamp"})
# Generate a corresponding input tibble
rows_in = []
for r in rows_soln:
s = list(r)
if s[2] == 0:
s[2] = '' # NaN counts
r_in = tuple(s)
rows_in.append(r_in)
if random() <= 0.15: # Random duplicates
for _ in range(randint(1, 4)):
rows_in.append(r_in)
df_in = DataFrame(rows_in, columns=cols_in + dummy_cols)
return df_in, df_soln
def ex0_split_df(df, max_splits=5):
from random import randint
from numpy import arange, sort, append
from numpy.random import shuffle, choice
# Shuffle the rows

11/1/2020 main
2/pmt2-sample-solutions (1)/midterm2/problem18/problem18.html 15/59
df = df.sample(frac=1).reset_index(drop= True )
# Split the rows
df_split = []
num_splits = min(randint(0, max_splits), len(df))
if num_splits > 0:
split_inds = sort(choice(arange(len(df)), size=num_splits, replace= Fal
se ))
if split_inds[0] > 0:
split_inds = append(0, split_inds)
if split_inds[-1] < len(df):
split_inds = append(split_inds, len(df))
for i, j in