Analysis of Proxy Voting Disclosures

from sec_api import FormNPXApi

formNpxApi = FormNPXApi(api_key="YOUR_API_KEY")

search_params = {
    "query": "cik:884546",
    "from": "0",
    "size": "1",
    "sort": [{"filedAt": {"order": "desc"}}],
}

# get N-PX filing metadata: registrant type, investment company type,
# series and class IDs, report type, period of report, and more
response = formNpxApi.get_metadata(search_params)
npx_filing_metadata = response["data"]

print(json.dumps(npx_filing_metadata, indent=2))

# get proxy voting records: issuer name, CUSIP, meeting date, vote description,
# vote categories, shares voted, how voted, management recommendation, and more
accessionNo = npx_filing_metadata[0]["accessionNo"]
response = formNpxApi.get_voting_records(accessionNo)
voting_records = response["proxyVotingRecords"]

print(json.dumps(voting_records[0], indent=2))

import sys
import time

YEARS = range(2025, 2023, -1)  # from 2024 to 2004
TEMP_FILE_TEMPLATE = "./temp_file_npx_{}.jsonl"
TARGET_FILE = "./form-npx-meta-data.jsonl.jsonl"


def process_year(year):
    backoff_time = random.randint(10, 800) / 1000
    print(f"Starting year {year} with backoff time {backoff_time:,}s")
    sys.stdout.flush()
    time.sleep(backoff_time)

    tmp_filename = TEMP_FILE_TEMPLATE.format(year)
    tmp_file = open(tmp_filename, "a")

    for month in range(12, 0, -1):
        search_from = 0
        month_counter = 0

        while True:
            query = f"filedAt:[{year}-{month:02d}-01 TO {year}-{month:02d}-31]"
            searchRequest = {
                "query": query,
                "from": search_from,
                "size": "50",
                "sort": [{"filedAt": {"order": "desc"}}],
            }

            response = None
            try:
                response = form_NPX_Api.get_metadata(searchRequest)
            except Exception as e:
                print(f"{year}-{month:02d} error: {e}")
                sys.stdout.flush()
                continue

            if response == None or len(response["data"]) == 0:
                break

            search_from += 50
            month_counter += len(response["data"])
            jsonl_data = "\n".join([json.dumps(entry) for entry in response["data"]])
            tmp_file.write(jsonl_data + "\n")

        print(f"Finished loading {month_counter} Form N-PX for {year}-{month:02d}")
        sys.stdout.flush()

    tmp_file.close()

    return year


if not os.path.exists(TARGET_FILE):
    with ThreadPoolExecutor(max_workers=4) as pool:
        processed_years = list(pool.map(process_year, YEARS))
    print("Finished processing all years.", processed_years)

    # merge the temporary files into one final file
    with open(TARGET_FILE, "a") as outfile:
        for year in YEARS:
            temp_file = TEMP_FILE_TEMPLATE.format(year)
            if os.path.exists(temp_file):
                with open(temp_file, "r") as infile:
                    outfile.write(infile.read())
else:
    print("File already exists. Skipping download.")

structured_data = pd.read_json(TARGET_FILE, lines=True)


# Convert stringified JSON in 'formData' and 'headerData' into dictionaries
def safe_json_load(value):
    """Convert stringified JSON to a dictionary safely."""
    if isinstance(value, str):
        try:
            return json.loads(value)  # Convert string to dict
        except json.JSONDecodeError:
            return {}  # Return empty dict if parsing fails
    return value  # Return as-is if it's already a dictionary


# Manually normalize formData and headerData
formData_flat = pd.json_normalize(structured_data["formData"].apply(safe_json_load))
headerData_flat = pd.json_normalize(structured_data["headerData"].apply(safe_json_load))

# Add prefix manually to avoid conflicts
formData_flat = formData_flat.add_prefix("formData.")
headerData_flat = headerData_flat.add_prefix("headerData.")

# Merge back into the main dataframe
structured_data = pd.concat(
    [
        structured_data.drop(columns=["formData", "headerData"]),
        formData_flat,
        headerData_flat,
    ],
    axis=1,
)

structured_data["filedAt"] = pd.to_datetime(structured_data["filedAt"], utc=True)
structured_data["filedAt"] = structured_data["filedAt"].dt.tz_convert("US/Eastern")
structured_data = structured_data.sort_values("filedAt", ascending=True).reset_index(
    drop=True
)
structured_data.drop_duplicates("accessionNo", keep="first", inplace=True)
structured_data["year"] = structured_data["filedAt"].dt.year
structured_data["month"] = structured_data["filedAt"].dt.month
structured_data["dayOfWeek"] = structured_data["filedAt"].dt.day_name()
# filedAtClass: preMarket (4:00AM-9:30AM), regularMarket (9:30AM-4:00PM), afterMarket (4:00PM-8:00PM)
structured_data["filedAtClass"] = structured_data["filedAt"].apply(
    lambda x: (
        "preMarket"
        if x.hour < 9 or (x.hour == 9 and x.minute < 30)
        else (
            "regularMarket"
            if x.hour < 16
            else "afterMarket" if x.hour < 20 else "other"
        )
    )
)

structured_data.head()

unique_years = structured_data["year"].nunique()
unique_companies = structured_data["cik"].nunique()
unique_filings = structured_data["accessionNo"].nunique()
min_year = structured_data["year"].min()
max_year = structured_data["year"].max()
print("Loaded dataframe with main documents of Form N-PX Proxy filings")
print(f"Number of filings: {unique_filings:,}")
print(f"Number of records: {len(structured_data):,}")
print(f"Number of years: {unique_years:,} ({min_year}-{max_year})")
print(f"Number of unique companies: {unique_companies:,}")

# structured_data.head()

npx_counts = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["year"])
    .size()
    .to_frame(name="count")
)

print(f"N-PX counts from 2024 to 2025.")
npx_counts.T

counts_month_yr_piv = (
    structured_data.groupby(["year", "month"]).size().unstack().fillna(0)
).astype(int)

# Ensure all months (1-12) are included in the index
counts_month_yr_piv = counts_month_yr_piv.reindex(columns=range(1, 13), fill_value=0)

# Convert to integer for better readability
counts_month_yr_piv = counts_month_yr_piv.astype(int)

print(f"Form N-PX counts by quarter from 2024 to 2025.")
counts_month_yr_piv.T

structured_data["qtr"] = structured_data["month"].apply(lambda x: (x - 1) // 3 + 1)

counts_qtr_yr_piv = (
    structured_data.groupby(["year", "qtr"]).size().unstack().fillna(0)
).astype(int)

counts_qtr_yr_piv = counts_qtr_yr_piv.reindex(columns=range(1, 5), fill_value=0)

print(f"Form N-PX counts by month from 2024 to 2025.")
counts_qtr_yr_piv.T

print(f"Length of structured_data: {len(structured_data)}")
structured_data = structured_data[
    structured_data["periodOfReport"].apply(lambda x: x.split("-")[0] == "2024")
]
print("length of structured_data after filtering for 2024: ", len(structured_data))

counts_filedAtClass = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["filedAtClass"])
    .size()
    .sort_values(ascending=False)
    .to_frame(name="Count")
).rename_axis("Publication Time")
counts_filedAtClass["Pct"] = (
    counts_filedAtClass["Count"].astype(int)
    / counts_filedAtClass["Count"].astype(int).sum()
).map("{:.0%}".format)
counts_filedAtClass["Count"] = counts_filedAtClass["Count"].map(lambda x: f"{x:,}")
counts_filedAtClass.index = (
    counts_filedAtClass.index.str.replace("preMarket", "Pre-Market (4:00 - 9:30 AM)")
    .str.replace("marketHours", "Market Hours (9:30 AM - 4:00 PM)")
    .str.replace("afterMarket", "After Market (4:00 - 8:00 PM)")
)
counts_filedAtClass = counts_filedAtClass.reindex(counts_filedAtClass.index[::-1])

print(
    f"N-PX counts by pre-market, regular market hours,\nand after-market publication time (2024)."
)
counts_filedAtClass

counts_dayOfWeek = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["dayOfWeek"])
    .size()
    .to_frame(name="Count")
).rename_axis("Day of the Week")
counts_dayOfWeek["Pct"] = (
    counts_dayOfWeek["Count"].astype(int) / counts_dayOfWeek["Count"].astype(int).sum()
).map("{:.0%}".format)
counts_dayOfWeek["Count"] = counts_dayOfWeek["Count"].map(lambda x: f"{x:,}")

print(f"Form N-PX disclosures by day of the week (2024).")
counts_dayOfWeek.loc[["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]]

count_formType = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["headerData.submissionType"])
    .size()
    .to_frame(name="Count")
).rename_axis("Submission Type")
count_formType["Pct"] = (
    count_formType["Count"].astype(int) / count_formType["Count"].astype(int).sum()
).map("{:.0%}".format)
count_formType["Count"] = count_formType["Count"].map(lambda x: f"{x:,}")

print(f"Form N-PX Disclosures by Submission Type (2024)")
count_formType

count_amendmentType = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["formData.coverPage.amendmentInfo.amendmentType"])
    .size()
    .to_frame(name="Count")
).rename_axis("Amendment Type")
count_amendmentType["Pct"] = (
    count_amendmentType["Count"].astype(int)
    / count_amendmentType["Count"].astype(int).sum()
).map("{:.0%}".format)
count_amendmentType["Count"] = count_amendmentType["Count"].map(lambda x: f"{x:,}")
count_amendmentType["Pct tot"] = (
    count_amendmentType["Count"].astype(int) / len(structured_data) * 100
).map("{:.2f}%".format)
count_amendmentType.sort_values("Count", ascending=True, inplace=True)

print(f"Form N-PX/A Amendment Disclosures by Amendment Type (2024)")
count_amendmentType

count_quarterOrYear = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(structured_data["formData.coverPage.yearOrQuarter"].str.strip())
    .size()
    .to_frame(name="Count")
).rename_axis("Report Cadence")
count_quarterOrYear["Pct"] = (
    count_quarterOrYear["Count"].astype(int)
    / count_quarterOrYear["Count"].astype(int).sum()
).map("{:.0%}".format)
count_quarterOrYear.sort_values("Count", ascending=False, inplace=True)
count_quarterOrYear["Count"] = count_quarterOrYear["Count"].map(lambda x: f"{x:,}")

print(f"Disclosures by Quarterly or Yearly Reporting Cadence (2024)")
count_quarterOrYear

count_registrantType = (
    structured_data.drop_duplicates(subset=["cik"])
    .groupby(structured_data["headerData.filerInfo.registrantType"].str.strip())
    .size()
    .to_frame(name="Count")
).rename_axis("Registrant Type")
count_registrantType["Pct"] = (
    count_registrantType["Count"].astype(int)
    / count_registrantType["Count"].astype(int).sum()
).map("{:.0%}".format)
count_registrantType["Count"] = count_registrantType["Count"].map(lambda x: f"{x:,}")

print(
    f"Number of Form N-PX Filers by Registrant Type (2024)\n"
    f"IM = Institutional Manager\n"
    f"RMIC = Registered Management Investment Company"
)

count_registrantType

count_includesProxyVotingRecords = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["proxyVotingRecordsAttached"])
    .size()
    .to_frame(name="Count")
).rename_axis("Includes Proxy Voting Records")
count_includesProxyVotingRecords.sort_values("Count", ascending=False, inplace=True)
count_includesProxyVotingRecords["Pct"] = (
    count_includesProxyVotingRecords["Count"].astype(int)
    / count_includesProxyVotingRecords["Count"].astype(int).sum()
).map("{:.0%}".format)
count_includesProxyVotingRecords["Count"] = count_includesProxyVotingRecords[
    "Count"
].map(lambda x: f"{x:,}")

print(f"Form N-PX Filings by Voting Data Availability (2024)")
count_includesProxyVotingRecords

count_reportType = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(["formData.coverPage.reportInfo.reportType"])
    .size()
    .to_frame(name="Count")
).rename_axis("Registrant Type")
count_reportType["Pct"] = (
    count_reportType["Count"].astype(int) / count_reportType["Count"].astype(int).sum()
).map("{:.0%}".format)
count_reportType.sort_values(by="Count", ascending=False, inplace=True)
count_reportType["Count"] = count_reportType["Count"].map(lambda x: f"{x:,}")

print(f"Number of Form N-PX Filings by Report Type (2024)\n")

count_reportType

count_noticeReason = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(
        structured_data["formData.coverPage.reportInfo.noticeExplanation"].str.strip()
    )  # Strip inside groupby
    .size()
    .to_frame(name="Count")
).rename_axis("Notice Explanation")

count_noticeReason["Pct"] = (
    count_noticeReason["Count"].astype(int)
    / count_noticeReason["Count"].astype(int).sum()
).map("{:.0%}".format)
count_noticeReason["Pct tot"] = (
    count_noticeReason["Count"].astype(int) / len(structured_data) * 100
).map("{:.2f}%".format)
count_noticeReason.sort_values(by="Count", ascending=False, inplace=True)
count_noticeReason["Count"] = count_noticeReason["Count"].map(lambda x: f"{x:,}")

print(f"Number of Form N-PX Filings by reason for why\n" "no votes were cast (2024)")

count_noticeReason

count_confidentiality = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(structured_data["formData.coverPage.reportInfo.confidentialTreatment"])
    .size()
    .to_frame(name="Count")
).rename_axis("Confidentiality Requested")
count_confidentiality["Pct"] = (
    count_confidentiality["Count"].astype(int)
    / count_confidentiality["Count"].astype(int).sum()
).map("{:.2%}".format)
count_confidentiality["Count"] = count_confidentiality["Count"].map(lambda x: f"{x:,}")

print(f"Number of Form N-PX Filings with a Confidentiality Request (2024)")

count_confidentiality

count_otherManagers = (
    structured_data.drop_duplicates(subset=["accessionNo"])
    .groupby(
        structured_data["formData.summaryPage.otherIncludedManagersCount"].fillna(0)
    )
    .size()
    .to_frame(name="Count")
).rename_axis("Other Manager Count")
count_otherManagers.index = count_otherManagers.index.astype(int)

count_otherManagers["Pct"] = (
    count_otherManagers["Count"].astype(int)
    / count_otherManagers["Count"].astype(int).sum()
).map("{:.2%}".format)
count_otherManagers.sort_values(by="Count", ascending=False, inplace=True)
count_otherManagers["Count"] = count_otherManagers["Count"].map(lambda x: f"{x:,}")

print(
    f"Number of Form N-PX Filings (2024)\n"
    "by Number Of Other Managers For Joint Reporting"
)

count_otherManagers.head(10)

structured_data["formData.summaryPage.otherIncludedManagersCount"].fillna(0).plot(
    kind="hist",
    bins=range(0, 26),
    color="steelblue",
    edgecolor="black",
    linewidth=0.5,
    figsize=(3.5, 2),
)
plt.grid(axis="x")
plt.yscale("log")
plt.xlabel("Number of Other Managers for Joint Reporting")
plt.ylabel("Number of N-PX Filings")

accessionNo_with_voting_records = structured_data[
    structured_data["proxyVotingRecordsAttached"] == True
][["accessionNo"]]
accessionNo_with_voting_records = [a[0] for a in accessionNo_with_voting_records.values]
accessionNo_with_voting_records[:5]

import json

YEARS = range(2025, 2023, -1)  # from 2025 to 2024
DATA_DIR = "./form-npx-proxy-voting-records"

os.makedirs(DATA_DIR, exist_ok=True)


def download_proxy_voting_records(accessionNo):
    try:
        filename = f"{DATA_DIR}/{accessionNo}_proxy_voting_record.json"
        if os.path.exists(filename):
            return accessionNo
        response = formNpxApi.get_voting_records(accessionNo)
        with open(f"{DATA_DIR}/{accessionNo}_proxy_voting_record.json", "w") as outfile:
            json.dump(response, outfile)

        return accessionNo

    except Exception as e:
        print(f"Error downloading {accessionNo}: {e}")
        return None


num_downloaded = len(os.listdir(DATA_DIR))

if num_downloaded < len(accessionNo_with_voting_records):
    print("Downloading proxy voting records...")
    with ThreadPoolExecutor(max_workers=4) as pool:
        downloaded_files = list(
            pool.map(download_proxy_voting_records, accessionNo_with_voting_records)
        )

    num_success_download = len([f for f in downloaded_files if f])

    print(
        f"Finished downloading {num_success_download}/{len(accessionNo_with_voting_records)} proxy voting records."
    )
else:
    print("Files already exists. Skipping download.")

print(f"Number of proxy voting records = {len(proxy_voting_records):,}")

count_voteCategory = (
    voteCategories.groupby(voteCategories["categoryType"].str.upper().str.strip())
    .size()
    .to_frame(name="Count")
).rename_axis("Vote Category")
count_voteCategory["Pct"] = (
    count_voteCategory["Count"].astype(int)
    / count_voteCategory["Count"].astype(int).sum()
).map("{:.2%}".format)

count_voteCategory.sort_values(by="Count", ascending=False, inplace=True)
count_voteCategory["Count"] = count_voteCategory["Count"].map(lambda x: f"{x:,}")

print(f"Number of Voting Records including specific Vote Category (2024)\n")

count_voteCategory.head(14)

shares_voted_and_on_loan["pctSharesVoted"].clip(0, 1).plot(
    kind="hist",
    bins=20,
    color="steelblue",
    edgecolor="black",
    linewidth=0.5,
    figsize=(3.5, 2),
)
plt.grid(axis="x")
plt.title("Shares Voted that are on loan (2024)")
plt.xlabel("Percentage of Shares Voted")
plt.ylabel("Number of Voting Records")
plt.yscale("log")

count_voteByFiler = (
    proxy_voting_records.groupby(proxy_voting_records["cik"])
    .size()
    .to_frame(name="Count")
).rename_axis("Filer")
count_voteByFiler["Pct"] = (
    count_voteByFiler["Count"].astype(int)
    / count_voteByFiler["Count"].astype(int).sum()
).map("{:.2%}".format)

count_voteByFiler.sort_values(by="Count", ascending=False, inplace=True)
count_voteByFiler["Count"] = count_voteByFiler["Count"].map(lambda x: f"{x:,}")

count_voteByFiler.index = count_voteByFiler.index.map(
    lambda x: f"{get_company_name(x)} ({x})"
)

print(f"Number of Voting Records by Company (2024)\n")

count_voteByFiler.head(15)

from sec_api import MappingApi

mappingApi = MappingApi(api_key="YOUR_API_KEY")

cusip_tesla = mappingApi.resolve("ticker", "^TSLA$")[0]["cusip"]
print(cusip_tesla)

proxyVotes_tesla = proxy_voting_records[proxy_voting_records["cusip"] == cusip_tesla]

# count the number of values of meetingDate
count_meetingDate_tesla = (
    proxyVotes_tesla.groupby(["meetingYear", "meetingMonth", "meetingDay"])
    .size()
    .to_frame(name="Count")
    .reset_index()
)
count_meetingDate_tesla.sort_values(
    "Count", ascending=False, inplace=True, ignore_index=True
)

print(
    f"Number of Proxy Voting Records by Meeting Date for Tesla shareholder meeting (2024)\n"
)
count_meetingDate_tesla.head(10)

# first get ciks for which an N-PX/A filing was made indicating errors in the initial filing
ciks_with_errors = structured_data[structured_data["formType"] == "N-PX/A"][
    "cik"
].unique()

proxyVotes_tesla = proxyVotes_tesla[~proxyVotes_tesla["cik"].isin(ciks_with_errors)]
len(proxyVotes_tesla)

count_voteByFiler_tesla = (
    proxyVotes_tesla.groupby(proxyVotes_tesla["cik"]).size().to_frame(name="Count")
).rename_axis("Filer")

# store a dict for later
vote_count_by_cik_tesla = count_voteByFiler_tesla["Count"].to_dict()

count_voteByFiler_tesla["Pct"] = (
    count_voteByFiler_tesla["Count"].astype(int)
    / count_voteByFiler_tesla["Count"].astype(int).sum()
).map("{:.2%}".format)

count_voteByFiler_tesla.sort_values(by="Count", ascending=False, inplace=True)
count_voteByFiler_tesla["Count"] = count_voteByFiler_tesla["Count"].map(
    lambda x: f"{x:,}"
)
count_voteByFiler_tesla.index = count_voteByFiler_tesla.index.map(
    lambda x: f"{get_company_name(x)} ({x})"
)

print(f"Number of Proxy Voting Records by Filer for Tesla shareholder meeting (2024)\n")

count_voteByFiler_tesla.head(15)

count_numberOfVotesByFiler_tesla = (
    proxyVotes_tesla.groupby("cik").agg({"sharesVoted": "sum"})
).rename_axis("Fund")
count_numberOfVotesByFiler_tesla["Pct"] = (
    count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int)
    / count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int).sum()
).map("{:.2%}".format)

# count_numberOfVotesByFiler_tesla.sort_values(by="Count", ascending=False, inplace=True)
count_numberOfVotesByFiler_tesla.sort_values(
    by="sharesVoted", ascending=False, inplace=True
)
count_numberOfVotesByFiler_tesla["sharesVoted"] = count_numberOfVotesByFiler_tesla[
    "sharesVoted"
].map(lambda x: f"{int(round(x)):,}")

count_numberOfVotesByFiler_tesla.index = count_numberOfVotesByFiler_tesla.index.map(
    lambda x: f"{get_company_name(x)} ({x})"
)


print(f"Number of Shares Voted by Fund at Tesla shareholder meeting (2024)\n")

count_numberOfVotesByFiler_tesla.head(15)

# check if the votes are cast either all for for, against, abstain, or withhold
# i.e. check if any of the rows of sharesVotedFor, sharesVotedAgainst,
# sharesVotedAbstain, sharesVotedWithhold are equal to sharesVoted
proxyVotes_tesla.loc[:, "unidirectionalVote"] = proxyVotes_tesla[
    "sharesVoted"
] == proxyVotes_tesla[
    [
        "sharesVotedFor",
        "sharesVotedAgainst",
        "sharesVotedAbstain",
        "sharesVotedWithhold",
    ]
].sum(
    axis=1
)

print("Number of Unidirectional Votes by Funds at the 2024 Tesla Shareholder Meeting")
proxyVotes_tesla["unidirectionalVote"].value_counts()

count_numberOfVotesByFiler_tesla = (
    proxyVotes_tesla.groupby(proxyVotes_tesla["cik"]).agg(
        {
            "sharesVoted": "sum",
            "sharesVotedFor": "sum",
            "sharesVotedAgainst": "sum",
            "sharesVotedAbstain": "sum",
            "sharesVotedWithhold": "sum",
            "sharesVotedWithManagement": "sum",
        }
    )
).rename_axis("Fund")

count_numberOfVotesByFiler_tesla["Pct"] = (
    count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int)
    / count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int).sum()
).map("{:.2%}".format)

for voteDirection in ["For", "Against", "Abstain", "Withhold", "WithManagement"]:
    count_numberOfVotesByFiler_tesla[f"Vote{voteDirection}Pct"] = (
        count_numberOfVotesByFiler_tesla[f"sharesVoted{voteDirection}"].astype(int)
        / count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int)
    ).map("{:.2%}".format)

count_numberOfVotesByFiler_tesla["Pct"] = (
    count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int)
    / count_numberOfVotesByFiler_tesla["sharesVoted"].astype(int).sum()
).map("{:.2%}".format)

# count_numberOfVotesByFiler_tesla.sort_values(by="Count", ascending=False, inplace=True)
count_numberOfVotesByFiler_tesla.sort_values(
    by="sharesVoted", ascending=False, inplace=True
)
count_numberOfVotesByFiler_tesla["sharesVoted"] = count_numberOfVotesByFiler_tesla[
    "sharesVoted"
].map(lambda x: f"{int(round(x)):,}")
count_numberOfVotesByFiler_tesla.index = count_numberOfVotesByFiler_tesla.index.map(
    lambda x: f"{get_company_name(x)} ({x})"
)


print(f"Direction of Votes by Company at Tesla Shareholder Meeting (2024)\n")

count_numberOfVotesByFiler_tesla[
    [
        "sharesVoted",
        "Pct",
        "VoteForPct",
        "VoteAgainstPct",
        "VoteWithholdPct",
        "VoteAbstainPct",
        "VoteWithManagementPct",
    ]
].head(40)