From 1874d9cdd49603e15323bb10932f48003eaf2353 Mon Sep 17 00:00:00 2001 From: Dave Date: Thu, 1 Feb 2024 10:20:18 -0800 Subject: [PATCH] First pass at analysis for David Slifka --- .gitignore | 1 + notebooks/slifka.ipynb | 559 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 560 insertions(+) create mode 100644 notebooks/slifka.ipynb diff --git a/.gitignore b/.gitignore index 3ead64c..23185b0 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ __pycache__/ *.py[cod] *$py.class +.DS_Store # C extensions *.so diff --git a/notebooks/slifka.ipynb b/notebooks/slifka.ipynb new file mode 100644 index 0000000..923a569 --- /dev/null +++ b/notebooks/slifka.ipynb @@ -0,0 +1,559 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Study donations made to DEM causes for the 2020 general election" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preliminaries\n", + "\n", + "Load data and define committees of interest:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 18287/18287 [00:00<00:00, 952597.40it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 3158 explicitly Democratic committees\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# ruff: noqa\n", + "from decimal import Decimal\n", + "import datetime\n", + "from tqdm import tqdm\n", + "\n", + "\n", + "democrat_party = \"DEM\"\n", + "\n", + "# IDs of FEC committees that are known to be *mostly* Democratic, even if they\n", + "# don't get reported that way in the FEC database. ActBlue is the key example:\n", + "# because they give to other not-strictly-DEM progressive groups, they're not\n", + "# marked as a DEM committee in the FEC database, but they're still a key\n", + "# Democratic fundraising tool.\n", + "\n", + "KNOWN_DEM_COMMITTEE_IDS = {\n", + " # ActBlue\n", + " \"C00401224\": \"ActBlue\",\n", + " # Biden Victory Fund\n", + " \"C00744946\": \"Biden Victory Fund\",\n", + " # MoveOn.org Political Action\n", + " \"C00341396\": \"MoveOn.org Political Action\",\n", + " # Golden Tennis Shoe PAC 2020\n", + " \"C00763003\": \"Golden Tennis Shoe PAC 2020\",\n", + " # The IMPACT Fund\n", + " \"C90020884\": \"The IMPACT Fund\",\n", + " # Washington Women for Choice\n", + " \"C00368332\": \"Washington Women for Choice\",\n", + " # Movement Voter PAC\n", + " \"C00728360\": \"Movement Voter PAC\",\n", + " # Fair Fight\n", + " \"C00693515\": \"Fair Fight\",\n", + " # EMILY's List\n", + " \"C00193433\": \"EMILY's List\",\n", + " # INDIVISIBLE Action\n", + " \"C00678839\": \"INDIVISIBLE Action\",\n", + " # National Democratic Redistricting PAC\n", + " \"C00630707\": \"National Democratic Redistricting PAC\",\n", + " # ONE FOR ALL Committee\n", + " \"C00752691\": \"ONE FOR ALL Committee\",\n", + "}\n", + "\n", + "\n", + "class CommitteeColumns:\n", + "\tID = 0\n", + "\tNAME = 1\n", + "\tPARTY = 10\n", + "\t\n", + "\n", + "dem_committees: dict[str, str] = dict(KNOWN_DEM_COMMITTEE_IDS)\n", + "\n", + "with open(\"../data/fec/committees-2020.txt\") as f:\n", + " for line in tqdm(f, total=18_287):\n", + " line = line.strip().split(\"|\")\n", + " if line[CommitteeColumns.PARTY] == democrat_party:\n", + " dem_committees[line[CommitteeColumns.ID]] = line[CommitteeColumns.NAME]\n", + "\n", + "print(f\"Found {len(dem_committees)} explicitly Democratic committees\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load the full FEC individual contributions dataset for 2019/2020.\n", + "\n", + "Filter out:\n", + "\n", + "1. Anything outside of the Nov 2019 - Nov 2020 window (there are some random dates in the FEC dataset)\n", + "2. Anything indicating it's an amendment to a previous transaction (`AMNDT_IND in {\"\", \"N\"}`)\n", + "3. Anything that isn't explicitly for the 2020 general election (`TRANSACTION_PGI != G2020`)\n", + "4. Anything that isn't explicitly an individual donation (`ENTITY_TYPE != IND`)\n", + "5. Anything that isn't for an DEM committee (or a handful of known exceptions; see above)\n", + "6. Anything with weird dollar amounts <= $0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 70659611/70659611 [04:29<00:00, 262293.44it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 4643882 contributions\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from dataclasses import dataclass\n", + "\n", + "@dataclass(frozen=True)\n", + "class Contributor:\n", + " \"\"\"A 'unified key' for a single contributor. Imperfect, but so be it.\"\"\"\n", + " name: str\n", + " city: str\n", + " state: str\n", + " employer: str\n", + " occupation: str\n", + " \n", + "\n", + "class ContributionColumns:\n", + " COMMITTEE_ID = 0\n", + " AMNDT_IND = 1\n", + " TRANSACTION_PGI = 3\n", + " ENTITY_TYPE = 6\n", + " NAME = 7\n", + " CITY = 8\n", + " STATE = 9\n", + " EMPLOYER = 10\n", + " OCCUPATION = 11\n", + " TRANSACTION_DATE = 13\n", + " TRANSACTION_AMOUNT = 14\n", + "\n", + "contributions: list[tuple[Contributor, datetime.date, str, float]] = []\n", + "with open(\"../data/fec/individual-2020.txt\") as f:\n", + " for line in tqdm(f, total=70_659_611):\n", + " splits = line.split(\"|\")\n", + "\n", + " # 1. Only consider contributions from November 3, 2019 (inclusive) to November 3, 2020 (exclusive)\n", + " try:\n", + " date_str = splits[ContributionColumns.TRANSACTION_DATE]\n", + " d = datetime.datetime.strptime(date_str, \"%m%d%Y\").date()\n", + " except:\n", + " continue\n", + " if d < datetime.date(2019, 11, 3):\n", + " continue\n", + " if d >= datetime.date(2020, 11, 3):\n", + " continue\n", + "\n", + " # 2. No amendments\n", + " if splits[ContributionColumns.AMNDT_IND] not in {\"\", \"N\"}:\n", + " continue\n", + "\n", + " # 3. General election contributions only\n", + " if splits[ContributionColumns.TRANSACTION_PGI] != \"G2020\":\n", + " continue\n", + "\n", + " # 4. Only consider individual contributions\n", + " donating_entity_type = splits[ContributionColumns.ENTITY_TYPE]\n", + " if donating_entity_type != \"IND\":\n", + " continue\n", + "\n", + " # 5. Only consider contributions to known DEM committees\n", + " committee_id = splits[ContributionColumns.COMMITTEE_ID]\n", + " if committee_id not in dem_committees:\n", + " continue\n", + "\n", + " # 6. Only consider contributions of > $0\n", + " amount_usd = float(splits[ContributionColumns.TRANSACTION_AMOUNT])\n", + " if amount_usd <= 0:\n", + " continue\n", + "\n", + " # It's a keeper!\n", + " contributor = Contributor(\n", + " name=splits[ContributionColumns.NAME].upper().strip(),\n", + " city=splits[ContributionColumns.CITY].upper().strip(),\n", + " state=splits[ContributionColumns.STATE].upper().strip(),\n", + " employer=splits[ContributionColumns.EMPLOYER].upper().strip(),\n", + " occupation=splits[ContributionColumns.OCCUPATION].upper().strip(),\n", + " )\n", + " contributions.append((contributor, d, committee_id, amount_usd))\n", + "\n", + "print(f\"Found {len(contributions)} contributions\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's group the contributions by contributor, where \"contributor\" is defined by the Contributor class above -- basically, they have to have the same name, city, state, employer, and occupation." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4643882/4643882 [00:05<00:00, 808163.79it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1250295 unique contributors\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "by_contributor: dict[Contributor, list[tuple[datetime.date, str, float]]] = {}\n", + "\n", + "for contributor, d, committee_id, amount_usd in tqdm(contributions):\n", + " if contributor not in by_contributor:\n", + " by_contributor[contributor] = []\n", + " by_contributor[contributor].append((d, committee_id, amount_usd))\n", + "\n", + "print(f\"Found {len(by_contributor)} unique contributors\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Weekly summaries\n", + "\n", + "Count # and total $ of contributions by week (using the ISO week-of-the-year)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4643882/4643882 [00:09<00:00, 505675.05it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved to ../data/weekly-contributions-2020.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Utility method\n", + "def get_start_date_of_iso_week(year, week_num):\n", + " \"\"\"Return the start date of an ISO week.\"\"\"\n", + " # Step 1: Find the first day of the year\n", + " jan_1 = datetime.datetime(year, 1, 1)\n", + " \n", + " # Step 2: Determine the date of the first Thursday in the year\n", + " # ISO weeks start on Monday, with the first week of the year containing the first Thursday.\n", + " days_to_thursday = 3 # From Monday to Thursday\n", + " first_thursday = jan_1 + datetime.timedelta(days=(3 - jan_1.weekday() + 7) % 7)\n", + " \n", + " # Step 3: Calculate the start date of the specified ISO week number\n", + " # Subtract one week since the calculation includes the first week\n", + " week_start_date = first_thursday + datetime.timedelta(weeks=week_num - 1) - datetime.timedelta(days=3)\n", + " \n", + " return week_start_date\n", + "\n", + "\n", + "# Count # and total $ of contributions by week (using the isocalendar() week number)\n", + "by_week_and_year: dict[datetime.date, tuple[int, float]] = {}\n", + "\n", + "for contribution in tqdm(contributions):\n", + " _, d, _, amount_usd = contribution\n", + " year, week_num, _ = d.isocalendar()\n", + " starting_date = get_start_date_of_iso_week(year, week_num)\n", + " if starting_date not in by_week_and_year:\n", + " by_week_and_year[starting_date] = (0, 0.0)\n", + " count, total = by_week_and_year[starting_date]\n", + " by_week_and_year[starting_date] = (count + 1, total + amount_usd)\n", + "\n", + "# Order it into (date, count, total, weighted_avg) tuples, from earliest to latest date.\n", + "# Make sure things aren't nested.\n", + "by_week_and_year_ordered_nested = sorted(\n", + " by_week_and_year.items(),\n", + " key=lambda x: x[0]\n", + ")\n", + "by_week_and_year_ordered = [\n", + " (date, count, total, total / count if count > 0 else 0.0)\n", + " for date, (count, total) in by_week_and_year_ordered_nested\n", + "]\n", + "\n", + "# Turn this into a pandas DataFrame\n", + "import pandas as pd\n", + "df = pd.DataFrame(by_week_and_year_ordered, columns=[\"week_starting\", \"count\", \"total_usd\", \"avg_usd\"])\n", + "# Make sure each column has the right type\n", + "df[\"week_starting\"] = pd.to_datetime(df[\"week_starting\"])\n", + "df[\"count\"] = df[\"count\"].astype(int)\n", + "df[\"total_usd\"] = df[\"total_usd\"].astype(float)\n", + "df[\"avg_usd\"] = df[\"avg_usd\"].astype(float)\n", + "\n", + "# Emit the DataFrame as a CSV\n", + "df.to_csv(\"../data/weekly-contributions-2020.csv\", index=False)\n", + "print(\"Saved to ../data/weekly-contributions-2020.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Graphing the weekly data!" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First, let's graph the weekly total contributions by total_usd in a given week_starting\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "fig, ax = plt.subplots()\n", + "# Make it bigger\n", + "fig.set_size_inches(18, 12)\n", + "ax.plot(df[\"week_starting\"], df[\"total_usd\"], label=\"Total USD\")\n", + "ax.set_title(\"Total USD of Contributions by Week\")\n", + "ax.set_xlabel(\"Week Starting\")\n", + "ax.set_ylabel(\"Total USD\")\n", + "ax.xaxis.set_major_locator(mdates.MonthLocator())\n", + "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + "ax.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's plot number of donations (`count`) by week\n", + "fig, ax = plt.subplots()\n", + "# Make it bigger\n", + "fig.set_size_inches(18, 12)\n", + "ax.plot(df[\"week_starting\"], df[\"count\"], label=\"Count\")\n", + "ax.set_title(\"Number of Contributions by Week\")\n", + "ax.set_xlabel(\"Week Starting\")\n", + "ax.set_ylabel(\"Count\")\n", + "ax.xaxis.set_major_locator(mdates.MonthLocator())\n", + "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + "ax.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# And finally, by average contribution amount in a given week\n", + "\n", + "fig, ax = plt.subplots()\n", + "# Make it bigger\n", + "fig.set_size_inches(18, 12)\n", + "ax.plot(df[\"week_starting\"], df[\"avg_usd\"], label=\"Average USD\")\n", + "ax.set_title(\"Average USD of Contributions by Week\")\n", + "ax.set_xlabel(\"Week Starting\")\n", + "ax.set_ylabel(\"Average USD\")\n", + "ax.xaxis.set_major_locator(mdates.MonthLocator())\n", + "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + "ax.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Big contributors\n", + "\n", + "Let's define big contributors in a few different ways." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1250295/1250295 [00:01<00:00, 1022021.36it/s]\n", + "100%|██████████| 1250295/1250295 [00:01<00:00, 1032787.78it/s]\n", + "100%|██████████| 1250295/1250295 [00:01<00:00, 1050511.00it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 8 contributors who gave >= $100,000\n", + "Found 332 contributors who gave >= $25,000\n", + "Found 7889 contributors who gave >= $5,000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Find all contributors who gave >= $100,000\n", + "\n", + "big_100k_contributors: dict[Contributor, list[tuple[datetime.date, str, float]]] = {}\n", + "for contributor, contributions in tqdm(by_contributor.items()):\n", + " total = sum(amount_usd for _, _, amount_usd in contributions)\n", + " if total >= 100_000:\n", + " big_100k_contributors[contributor] = contributions\n", + "\n", + "# And again for $25k\n", + "big_25k_contributors: dict[Contributor, list[tuple[datetime.date, str, float]]] = {}\n", + "for contributor, contributions in tqdm(by_contributor.items()):\n", + " total = sum(amount_usd for _, _, amount_usd in contributions)\n", + " if total >= 25_000 and total < 100_000:\n", + " big_25k_contributors[contributor] = contributions\n", + "\n", + "# And again for $5k\n", + "big_5k_contributors: dict[Contributor, list[tuple[datetime.date, str, float]]] = {}\n", + "for contributor, contributions in tqdm(by_contributor.items()):\n", + " total = sum(amount_usd for _, _, amount_usd in contributions)\n", + " if total >= 5_000 and total < 25_000:\n", + " big_5k_contributors[contributor] = contributions\n", + "\n", + "print(f\"Found {len(big_100k_contributors)} contributors who gave >= $100,000\")\n", + "print(f\"Found {len(big_25k_contributors)} contributors who gave >= $25,000\")\n", + "print(f\"Found {len(big_5k_contributors)} contributors who gave >= $5,000\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}