if color_palette == "deep":

c = sb.color_palette("deep")

c1, c2, c3 = c[2], c[3], c[5]

elif color_palette == "husl":

c = sb.color_palette(color_palette)

c1, c2, c3 = c[5], c[4], c[3]

else:

c = sb.color_palette(color_palette)

c1, c2, c3 = c[2], c[0], sb.color_palette("husl")[3]

l, h = round(lo), round(hi)

g = dataframe

if 'revision' in groupby_key:

update = 'Revision'

gdown = g[g[groupby_key] <= lo]

gmid = g[(g[groupby_key] > lo) & (g[groupby_key] < hi)]

gup = g[g[groupby_key] >= hi]

dplotargs = [

(gdown, c1, "Price {update} <= {l}%".format(update=update, l=l), 0.06),

(gmid, c2, "{l}% < {update} < {h}%".format(update=update, l=l,h=h), 0.03),

(gup, c3, "Price {update} >= {h}%".format(update=update, h=h), 0.02)

]

else:

update = 'Amendment'

gdown = g[g[groupby_key] < lo]

gmid = g[(g[groupby_key] >= lo) & (g[groupby_key] <= hi)]

gup = g[g[groupby_key] > hi]

dplotargs = [

(gdown, c1, "Price {update} < {l}%".format(update=update, l=l), 0.06),

(gup, c2, "Price {update} > {h}%".format(update=update, h=h), 0.015)

]

"Plots conditional underpricing distributions. Run set_data(df) first."

f, ax = plt.subplots(1,1,figsize=(16, 5), sharex=True)

for arg in plotargs:

df, c, l, h = arg

sb.distplot(df[return_key], ax=ax,

kde_kws={"label": l + " Obs={N}".format(N=len(df)), "color": c},

hist_kws={"histtype": "stepfilled", "color": c})

r = df[return_key]

m,s,y,med = r.mean(), r.std(), r.skew(), r.median()

ax.annotate(

u'μ={:.2f}%, σ={:.2f}, γ={:.2f}'.format(m,s,y),

xy=(med+2, h), xytext=(med+6, h+0.01),

arrowprops=dict(facecolor=cl.rgb2hex(c), width=1.5, headwidth=5, shrink=0.1))

H, prob = kruskalwallis(*[x[0][return_key] for x in plotargs])

ax.annotate("Kruskal-Wallis: (H={H:.2f}, prob={p:.3f})".format(H=H, p=prob),

xy=(66,0.01))

plt.title("Conditional Underpricing Distributions %s" % update_type)

plt.ylabel("Density")

plt.xlim(xmin=-40,xmax=100)

plt.xlabel("1st Day Returns (%)")

### Revisions

c = sb.color_palette("deep")

"""

c = sb.color_palette("deep")

c1, c2 , c3 = c[2], c[3], c[5]

g, gdown, gmid, gup, dplotargs = set_data(revisions,

groupby_key='percent_final_price_revision',

hi=10, lo=-0,

color_palette='deep' )

sb_distplots(dplotargs, update_type="(Price Revisions)")

# plt.savefig("conditional-returns-revisions.png", dpi=200)

sb.jointplot("percent_final_price_revision", "close_return", gdown, kind='reg', color=c1, size=6, ylim=(-100, 200), xlim=(-80, 0))

plt.savefig("./jointplot-red.png")

sb.jointplot("percent_final_price_revision", "close_return", gmid, kind='reg', color=c2, size=6, ylim=(-100, 200), xlim=(0,10))

plt.savefig("./jointplot-purple.png")

sb.jointplot("percent_final_price_revision", "close_return", gup, kind='reg', color=c3, size=6, ylim=(-100, 200), xlim=(10,100))

plt.savefig("./jointplot-blue.png")

"""

### Updates

"""

# c = sb.color_palette("husl")

# c1, c2 , c3 = c[5], c[4], c[3]

c = sb.color_palette('colorblind')

c1, c2, c3 = c[2], c[0], sb.color_palette("husl")[3]

g, gdown, gmid, gup, dplotargs = set_data(amendments,

groupby_key='percent_first_price_update',

hi=0, lo=0,

color_palette='colorblind' )

sb_distplots(dplotargs, update_type="(Price Updates)")

# plt.savefig("conditional-returns-updates.png", dpi=200)

sb_distplots(dplotargs, update_type="(Price Updates)")

# plt.savefig("conditional-returns-updates.png", dpi=200)

sb.jointplot("percent_first_price_update", "close_return", gdown, kind='reg', color=c1, size=6, ylim=(-50, 200), xlim=(-80, 0))

plt.savefig("./jointplot-down-updates.png")

sb.jointplot("percent_first_price_update", "close_return", gup, kind='reg', color=c2, size=6, ylim=(-50, 200), xlim=(0, 80))

plt.savefig("./jointplot-up-updates.png")

s2 = amendments[['percent_first_price_update' , 'percent_final_price_revision', 'underwriter_tier']]

s2 = s2[s2['underwriter_tier'] != '-1']

s2.columns = ['First Price Update (%)','Final Price Revision (%)', 'Rank']

colors = cp_four("cool_r")

cool_r = [

(0.88235294117647056, 0.11764705882352941, 1.0),

(0.52941176470588236, 0.47058823529411764, 1.0),

(0.23529411764705888, 0.76470588235294112, 1.0)

]

cblind = [

sb.color_palette('colorblind')[2],

sb.color_palette('colorblind')[0],

sb.color_palette('colorblind')[5],

]

common = [ # red, purple, blue

sb.color_palette()[2],

sb.color_palette()[3],

sb.color_palette()[5],

]

common = [

(0.15, 0.2870588235294118, 0.4480392156862745),

sb.color_palette('colorblind')[0],

(0.9352941176470589, 0.5686274509803922, 0.2),

]

g = sb.PairGrid(s2, hue='Rank',

palette=common,

size=5)

g.map_upper(sb.regplot, scatter_kws={"s": 8})

g.map_lower(plt.scatter, s=10)

g.map_diag(plt.hist)

# g.map_upper(sb.kdeplot, cmap="Grey")

g.set(xlim=(-80, 80), xticks=[-80, -60, -40, -20, 0, 20, 40, 60, 80],

ylim=(-80, 80), yticks=[-80, -60, -40, -20, 0, 20, 40, 60, 80]);

g.add_legend()

plt.scatter(revisions.percent_first_price_update,

revisions.percent_final_price_revision,

c=common[0], s=12 )

plt.xlim(-80,80)

plt.ylim(-80,80)

plt.xlabel('First Price Update (%)')

plt.ylabel('Final Price Revision (%)')

### Just scatterplot

r1, r0, r7, r9 = [x[1] for x in revisions.groupby('underwriter_tier')]

plt.scatter(r0.percent_first_price_update, r0.percent_final_price_revision,

c=common[0], s=12, label='Rank: 0+')

plt.scatter(r7.percent_first_price_update, r7.percent_final_price_revision,

c=common[1], s=12, label='Rank: 7+')

plt.scatter(r9.percent_first_price_update, r9.percent_final_price_revision,

c=common[2], s=12, label='Rank: 8.5+')

plt.xlim(-80,80)

plt.ylim(-80,80)

plt.xlabel('First Price Amendment (%)')

plt.ylabel('Final Price Revision (%)')

'Plots price-update histograms'

colors2 = sb.color_palette("husl")

c = sb.color_palette("deep")

###### Price updates

m, s = amendments['size_of_first_price_update'].mean(), amendments['size_of_first_price_update'].std()

plt.hist(amendments['size_of_first_price_update'],

bins=63, alpha=0.6, color=c[3], label="First Price Update\n μ = {:.2f}\n σ = {:.2f}\n N = {}".format(m, s, len(amendments)))

# plt.xticks(xy[1])

plt.legend()

plt.xlim(-10,10)

plt.ylabel("Frequency")

plt.xlabel("Dollar Price Change ($)")

###### Price revisions

m, s = revisions['size_of_final_price_revision'].mean(), revisions['size_of_final_price_revision'].std()

plt.hist(revisions['size_of_final_price_revision'],

bins=48, alpha=0.6, label="Final Price Revision\n μ = {:.2f}\n σ = {:.2f}\n N = {}".format(m, s, len(revisions)))

revisions.loc['1117106', 'size_of_final_price_revision'] = 11.5

# plt.xticks(xy[1])

plt.legend()

plt.xlim(-12,12)

plt.ylabel("Frequency")

plt.xlabel("Dollar Price Change ($)")

# for cik in df.index:

# if np.isnan(df.loc[cik, 'percent_first_price_update']):

# df.loc[cik, 'pct_first_price_change'] = df.loc[cik, 'percent_final_price_revision']

# else:

# df.loc[cik, 'pct_first_price_change'] = df.loc[cik, 'percent_final_price_revision']

plt.plot(df.percent_first_price_update, df.percent_final_price_revision)

# xy = sb.lmplot("underwriter_rank_single", "underwriter_rank_avg", data=df)

# xy.set_xlabels("CM-Rank - Single Top Underwriter")

# Set matplotlibrc backend: TkAgg instead of MacOSX

# ATTENTION

sb.lmplot("ln_CASI_all_finance", "percent_first_price_update", revisions,

# hue="amends",

palette="deep",

# robust=True,

# ci=95,

# n_boot=500,

)

# plt.ylim((-50,50))

# days_from_priced_to_listing

# days_to_first_price_update

# percent_first_price_update

# ATTENTION

sb.lmplot("ln_CSI_all_finance", "percent_final_price_revision", revisions,

hue="underwriter_tier", palette="deep",

# robust=True,

# ci=95,

# n_boot=500,

)

plt.ylim((-50,50))

obs_num = {x[0]:len(x[1]) for x in df.groupby('underwriter_tier')}

legend_labs = {'-1': "No Underwriter: N={}",

'0+': "Rank 0+: N={}",

'7+': "Rank 7+: N={}",

'9' : "Rank 9: N={}"}

legend_labs = sorted(legend_labs[k].format(obs_num[k]) for k in obs_num)

plt.legend(legend_labs)

plt.xlabel(r"$log(CASI)$")

plt.ylim((-50,50))

plt.xlim((-20,20))

plt.title('Abnormal attention and Price Updates')

f, ax = plt.subplots(1,1, figsize=(12, 4), sharex=True)

cpalette = sb.color_palette(color)

for arg in plotargs:

df, label, color_num = arg

color = cpalette[color_num]

# Summary stats:

mean = df[kkey].mean()

med = df[kkey].median()

std = df[kkey].std()

skew = df[kkey].skew()

stat = u"\nμ={:0.2f} med={:0.2f}\nσ={:0.2f} N={}".format(

mean, med, std, len(df))

label += stat

yvals, xvals, patchs = plt.hist(df[kkey].tolist(), bins=100, label=label,

color=color, alpha=0.6, histtype='stepfilled')

H, prob = kruskalwallis(*[x[0][kkey] for x in plotargs])

# U, prob = mannwhitneyu(*[x[0][kkey] for x in plotargs])

ax.annotate("Kruskal-Wallis:\nH={H:.2f}\nprob={p:.3f}".format(H=H, p=prob),

xy=(kw_xy[0], kw_xy[1]))

plt.ylabel("Frequency")

from lifelines.estimation import KaplanMeierFitter

from lifelines.statistics import logrank_test

import matplotlib.pyplot as plt

duration_keys = ["days_from_priced_to_listing",

"days_to_final_price_revision",

# "days_to_first_price_update",

"days_from_s1_to_listing",

"days_to_first_price_change"]

duration_key = duration_keys[-1]

kmf = KaplanMeierFitter()

f, ax = plt.subplots(1,1,figsize=(12, 4), sharex=True)

T = 1 # annotation line thickness

xoffset = 0.4 # annotation offset (x-axis)

yoffset = 0.04

# Above filing price range

kmf.fit(above[duration_key], label='Upward Price Amendment: N={}'.format(len(above)), alpha=0.9)

kmf.plot(ax=ax, c=colors[5], alpha=0.7)

quartiles = [int(np.percentile(kmf.durations, x)) for x in [25, 50, 75]][::-1]

aprops = dict(facecolor=colors[5], width=T, headwidth=T)

plt.annotate("75%: {} days".format(quartiles[0]),

(quartiles[0], 0.25),

xytext=(quartiles[0]+xoffset, 0.25+yoffset),

arrowprops=aprops)

plt.annotate("50%: {} days".format(quartiles[1]),

(quartiles[1], 0.50),

xytext=(quartiles[1]+xoffset, 0.50+yoffset),

arrowprops=aprops)

plt.annotate("25%: {} days".format(quartiles[2]),

(quartiles[2], 0.75),

xytext=(quartiles[2]+xoffset, 0.75+yoffset),

arrowprops=aprops)

# Under filing price range

kmf.fit(under[duration_key], label='Downward Price Amendment: N={}'.format(len(under)),)

kmf.plot(ax=ax, c=colors[2], alpha=0.7)

quartiles = [int(np.percentile(kmf.durations, x)) for x in [25, 50, 75]][::-1]

aprops = dict(facecolor=colors[2], width=T, headwidth=T)

plt.annotate("75%: {} days".format(quartiles[0]),

(quartiles[0], 0.25),

xytext=(quartiles[0]+xoffset, 0.25+yoffset+0.05),

arrowprops=aprops)

plt.annotate("50%: {} days".format(quartiles[1]),

(quartiles[1], 0.50),

xytext=(quartiles[1]+xoffset, 0.50+yoffset+0.05),

arrowprops=aprops)

plt.annotate("25%: {} days".format(quartiles[2]),

(quartiles[2], 0.75),

xytext=(quartiles[2]+xoffset, 0.75+yoffset+0.05),

arrowprops=aprops)

# log rank tests + general graph labels

# summary, p_value, results = logrank_test(

# above[duration_key],

# within[duration_key],

# under[duration_key],

# alpha=0.95)

# ax.annotate("Log-rank test: (prob={p:.3f})".format(p=p_value),

# xy=(1210, 0.08))

plt.ylim(0,1)

plt.xlim(0, max(np.percentile(above[duration_key], 90), np.percentile(under[duration_key],90)))

plt.title("Kaplan-Meier Survival Functions")

plt.xlabel("Delay (days) in {}".format(duration_key))

if uw_rank > 8.5:

return "8.5+"

elif uw_rank > 7:

return "7+"

elif uw_rank >= 0:

return "0+"

elif uw_rank < 0: