more_attributes_preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "Configure notebook and download index files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 468 µs (started: 2022-02-09 23:26:47 +00:00)\n"
     ]
    }
   ],
   "source": [
    "# To have time runtime for cells\n",
    "try:\n",
    "    %load_ext autotime\n",
    "except:\n",
    "    !pip install ipython-autotime\n",
    "    %load_ext autotime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install irsx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting index file for year: 2021 remote=https://s3.amazonaws.com/irs-form-990/index_2021.csv local=/opt/conda/miniconda3/lib/python3.8/site-packages/irsx/CSV/index_2021.csv\n",
      "Beginning streaming download of https://s3.amazonaws.com/irs-form-990/index_2021.csv\n",
      "Total file size: 55.76 MB\n",
      "Download completed to /opt/conda/miniconda3/lib/python3.8/site-packages/irsx/CSV/index_2021.csv in 0:00:01.413513\n",
      "time: 2.13 s (started: 2022-02-09 23:26:47 +00:00)\n"
     ]
    }
   ],
   "source": [
    "#Download Index file which contains the object_id which are required to download the IRS files\n",
    "!irsx_index --year=2021 --verbose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing filing 202012339349300801\n",
      "Printing result to file temp\n",
      "File already available at /opt/conda/miniconda3/lib/python3.8/site-packages/irsx/XML/202012339349300801_public.xml -- skipping\n",
      "Filing 202012339349300801 is version 2019v5.1\n",
      "In 202012339349300801 keyerrors: [{'schedule_name': 'IRS990', 'group_keyerrors': [], 'keyerrors': [{'element_path': '/IRS990/DonorRstrOrQuasiEndowmentsInd'}, {'element_path': '/IRS990/BusinessRlnWith35CtrlEntInd'}, {'element_path': '/IRS990/OrganizationFollowsFASB117Ind'}, {'element_path': '/IRS990/NoDonorRestrictionNetAssetsGrp/BOYAmt'}, {'element_path': '/IRS990/NoDonorRestrictionNetAssetsGrp/EOYAmt'}]}]\n",
      "\n",
      "\n",
      "time: 644 ms (started: 2022-02-09 23:26:50 +00:00)\n"
     ]
    }
   ],
   "source": [
    "!irsx --file temp --verbose 202012339349300801"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformation\n",
    "Runterladen der einzelnen XML Files mit Spark, auslesen der wichtigen Daten und schreiben in ein Dateiformat, welches besser für die Analyse geeignet ist.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 809 µs (started: 2022-02-09 23:26:50 +00:00)\n"
     ]
    }
   ],
   "source": [
    "#Set path of index file, and amount of lines to be read (amount of IRS files later processed)\n",
    "path = \"/opt/conda/miniconda3/lib/python3.8/site-packages/irsx/CSV/index_2021.csv\"\n",
    "nrows = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RETURN_ID  FILING_TYPE  EIN        TAX_PERIOD  SUB_DATE               TAXPAYER_NAME                                        RETURN_TYPE  DLN             OBJECT_ID\n",
      "17606342   EFILE        452772761  201906      1/21/2021 10:02:51 AM  CAMDENS CHARTER SCHOOL NETWORK INC                   990          93493065013010  202010659349301301  \n",
      "17606343   EFILE        237061115  201906      1/21/2021 10:02:51 AM  JACKSON STATE UNIVERSITY DEVELOPMENT FOUNDATION INC  990          93493072000410  202010729349300041  \n",
      "17606347   EFILE        344427516  201904      1/21/2021 10:02:52 AM  TIFFIN UNIVERSITY                                    990          93493072000210  202010729349300021  \n",
      "17606350   EFILE        840865247  201912      1/21/2021 10:03:29 AM  NETWORK MINISTRIES INC                               990          93493072008360  202010729349300836  \n",
      "time: 157 ms (started: 2022-02-09 23:26:50 +00:00)\n"
     ]
    }
   ],
   "source": [
    "#Have a look at the index file to get an idea, we need the last column (zoom out to see whole file)\n",
    "!head -5 {path} | column -t -s,  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 2.79 s (started: 2022-02-09 23:26:50 +00:00)\n"
     ]
    }
   ],
   "source": [
    "# Read indexfile as PandasDF, extract object_ids and convert to PysparkDF\n",
    "import pandas as pd\n",
    "from pyspark.sql.session import SparkSession\n",
    "from pyspark.sql.types import StringType\n",
    "\n",
    "spark = SparkSession.builder.getOrCreate()\n",
    "\n",
    "df21 = pd.read_csv(path, index_col=False, dtype=str, nrows= nrows) # read all as string, not beautiful but we only need object id anyways\n",
    "\n",
    "sdf = spark.createDataFrame(df21[\"OBJECT_ID\"], StringType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 39.1 ms (started: 2022-02-09 23:26:53 +00:00)\n"
     ]
    }
   ],
   "source": [
    "#Define custom transformation which downloads the IRS files via IRSX, transforms it into a python dict and extracts the required fields\n",
    "from irsx.xmlrunner import XMLRunner\n",
    "from pyspark.sql.types import StringType, StructType, StructField, IntegerType\n",
    "from pyspark.sql.functions import udf\n",
    "\n",
    "xml_runner = XMLRunner()\n",
    "def transform_data(object_id):\n",
    "    try: #Download files with basic error handling\n",
    "        filing = xml_runner.run_filing(object_id)\n",
    "        schedules = filing.list_schedules()\n",
    "    except: \n",
    "        print(f\"Transform error for id {object_id}\")\n",
    "        return [\"\", \"\", \"\", \"\", 0, 0, 0, 0, 0, 0, 0, 0]\n",
    "    \n",
    "    \n",
    "    # Initialize with values to avoid NANs \n",
    "    ein, state, name = \"\", \"\", \"\"\n",
    "    state, name, revenue, revenueEZ, vol_cnt, empl_cnt, rvn_ls_exp, liab_eoy, liab_boy,assts_eoy, assts_boy = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
    "    \n",
    "    #For different IRS forms the data is in different places, get the required \n",
    "    if \"ReturnHeader990x\" in schedules:\n",
    "        header = filing.get_parsed_sked(\"ReturnHeader990x\")\n",
    "        header_part_i = header[0][\"schedule_parts\"][\"returnheader990x_part_i\"]\n",
    "        ein = header_part_i[\"ein\"]\n",
    "        state = header_part_i.get(\"USAddrss_SttAbbrvtnCd\", \"XX\")\n",
    "        name = header_part_i[\"BsnssNm_BsnssNmLn1Txt\"]\n",
    "        \n",
    "    if \"IRS990EZ\" in schedules:\n",
    "        irs990ez = filing.get_parsed_sked(\"IRS990EZ\")\n",
    "        irs990ez_part_i = irs990ez[0][\"schedule_parts\"].get(\"ez_part_i\", None)\n",
    "        if irs990ez_part_i:\n",
    "            revenueEZ = irs990ez_part_i.get(\"TtlRvnAmt\", 0)        \n",
    "    \n",
    "    if \"IRS990\" in schedules:\n",
    "        irs990 = filing.get_parsed_sked(\"IRS990\")\n",
    "        irs990_part_i = irs990[0][\"schedule_parts\"][\"part_i\"]\n",
    "        revenue = irs990_part_i[\"CYTtlRvnAmt\"]\n",
    "        vol_cnt = int(irs990_part_i.get(\"TtlVlntrsCnt\", 0))\n",
    "        empl_cnt = int(irs990_part_i.get(\"TtlEmplyCnt\", 0))\n",
    "        rvn_ls_exp = int(irs990_part_i.get(\"CYRvnsLssExpnssAmt\", 0))\n",
    "        liab_eoy = int(irs990_part_i.get(\"TtlLbltsEOYAmt\", 0))\n",
    "        liab_boy = int(irs990_part_i.get(\"TtlLbltsBOYAmt\", 0))\n",
    "        assts_eoy = int(irs990_part_i.get(\"TtlAsstsEOYAmt\", 0))\n",
    "        assts_boy = int(irs990_part_i.get(\"TtlAsstsBOYAmt\", 0))\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "    revenue = int(revenue) + int(revenueEZ) #Sum the two rev values because we want to only return one\n",
    "    return [object_id, ein, state, name, revenue, vol_cnt, empl_cnt, rvn_ls_exp, liab_eoy, liab_boy,assts_eoy, assts_boy ]\n",
    "     \n",
    "#Define PySpark Schema    \n",
    "my_schema = StructType([\n",
    "    StructField(\"ObjectID\", StringType(), nullable=False),\n",
    "    StructField(\"EIN\", StringType(), nullable=False),\n",
    "    StructField(\"State\", StringType(), nullable=False),\n",
    "    StructField(\"Name\", StringType(), nullable=False),\n",
    "    StructField(\"Revenue\", IntegerType(), nullable=False),\n",
    "    StructField(\"TtlVlntrsCnt\", IntegerType(), nullable=False),\n",
    "    StructField(\"TtlEmplyCnt\", IntegerType(), nullable=False),\n",
    "    StructField(\"CYRvnsLssExpnssAmt\", IntegerType(), nullable=False),\n",
    "    StructField(\"TtlLbltsEOYAmt\", IntegerType(), nullable=False),\n",
    "    StructField(\"TtlLbltsBOYAmt\", IntegerType(), nullable=False),\n",
    "    StructField(\"TtlAsstsEOYAmt\", IntegerType(), nullable=False),\n",
    "    StructField(\"TtlAsstsBOYAmt\", IntegerType(), nullable=False),\n",
    "])\n",
    "\n",
    "spark_transform_data = udf(lambda z: transform_data(z), my_schema)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['202021359349301552',\n",
       " '541965765',\n",
       " 'VA',\n",
       " 'PARK PLACE SCHOOL INC',\n",
       " 671334,\n",
       " 56,\n",
       " 19,\n",
       " -14709,\n",
       " 6015,\n",
       " 14414,\n",
       " 725910,\n",
       " 750315]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 65.9 ms (started: 2022-02-09 23:26:53 +00:00)\n"
     ]
    }
   ],
   "source": [
    "#Basic example of what the function return\n",
    "transform_data(\"202021359349301552\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n",
      "== Physical Plan ==\n",
      "*(2) Project [pythonUDF0#36.ObjectID AS ObjectID#12, pythonUDF0#36.EIN AS EIN#13, pythonUDF0#36.State AS State#14, pythonUDF0#36.Name AS Name#15, pythonUDF0#36.Revenue AS Revenue#16, pythonUDF0#36.TtlVlntrsCnt AS TtlVlntrsCnt#17, pythonUDF0#36.TtlEmplyCnt AS TtlEmplyCnt#18, pythonUDF0#36.CYRvnsLssExpnssAmt AS CYRvnsLssExpnssAmt#19, pythonUDF0#36.TtlLbltsEOYAmt AS TtlLbltsEOYAmt#20, pythonUDF0#36.TtlLbltsBOYAmt AS TtlLbltsBOYAmt#21, pythonUDF0#36.TtlAsstsEOYAmt AS TtlAsstsEOYAmt#22, pythonUDF0#36.TtlAsstsBOYAmt AS TtlAsstsBOYAmt#23]\n",
      "+- BatchEvalPython [<lambda>(value#0)], [pythonUDF0#36]\n",
      "   +- *(1) Scan ExistingRDD[value#0]\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 4:>                                                          (0 + 2) / 2]\r"
     ]
    }
   ],
   "source": [
    "# Apply the transformation function and write the result as csv and parquet to HDFS\n",
    "anz = sdf.count()\n",
    "print(anz)\n",
    "sdf2 = sdf.withColumn('valuelist', spark_transform_data('value')).select(\"valuelist.*\")\n",
    "sdf2.explain()\n",
    "sdf2.write.mode('overwrite').csv(f\"hdfs://big-spark-cluster-m/user/root/{anz}ps.csv\")\n",
    "sdf2.write.mode('overwrite').save(f\"hdfs://big-spark-cluster-m/user/root/{anz}ps.parquet\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zeiten von erfolgreichen Läufen (u.a. aufgrund von Caching nicht sinnvoll vergleichbar)\n",
    "\n",
    "|Anzahl | Zeit| Kommentar |  \n",
    "-------|--------|---------------\n",
    "|4710 | time: 2min 44s (started: 2022-01-17 18:46:15 +00:00) | erster Versuch (zusätzlicher Zeitbedarf für Sampling  & lokal)|\n",
    "|46099| time: 12min 22s (started: 2022-01-17 20:42:31 +00:00) | erster Versuch mit ErrorHandling (zusätzlicher Zeitbedarf für Sampling & lokal)|\n",
    "|184781| time: 1h 14min 7s (started: 2022-01-25 12:37:15 +00:00) | -  (zusätzlicher Zeitbedarf für Sampling & lokal)|\n",
    "|184781| time: 14min 23s (started: 2022-02-02 11:34:34 +00:00) | mehr Attribute, dafür kein Samplen mehr sonder direkt beim Einlesen, speichern in HDFS|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aggregation\n",
    "In diesem Schritt wird das gerade erzeugte File wieder eingelesen, um Analysen zu ermöglichen.  \n",
    "Hier ist die Verwendung von Pyspark nicht mehr zwangsläufig erforderlich, wird aber für unser einfaches Beispiel trotzdem verwendet.  \n",
    "Wenn Pyspark verwendet wird, sollte das File auf HDFS liegen, damit alle Worker Zugriff darauf haben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- ObjectID: string (nullable = true)\n",
      " |-- EIN: string (nullable = true)\n",
      " |-- State: string (nullable = true)\n",
      " |-- Name: string (nullable = true)\n",
      " |-- Revenue: integer (nullable = true)\n",
      " |-- TtlVlntrsCnt: integer (nullable = true)\n",
      " |-- TtlEmplyCnt: integer (nullable = true)\n",
      " |-- CYRvnsLssExpnssAmt: integer (nullable = true)\n",
      " |-- TtlLbltsEOYAmt: integer (nullable = true)\n",
      " |-- TtlLbltsBOYAmt: integer (nullable = true)\n",
      " |-- TtlAsstsEOYAmt: integer (nullable = true)\n",
      " |-- TtlAsstsBOYAmt: integer (nullable = true)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(pyspark.sql.dataframe.DataFrame,\n",
       " None,\n",
       " [Row(ObjectID='202010659349301301', EIN='452772761', State='NJ', Name=\"CAMDEN'S CHARTER SCHOOL\", Revenue=5148336, TtlVlntrsCnt=0, TtlEmplyCnt=6, CYRvnsLssExpnssAmt=1302111, TtlLbltsEOYAmt=15896401, TtlLbltsBOYAmt=17300598, TtlAsstsEOYAmt=24491485, TtlAsstsBOYAmt=24842081),\n",
       "  Row(ObjectID='202010729349300041', EIN='237061115', State='MS', Name='JACKSON STATE UNIVERSITY', Revenue=10386900, TtlVlntrsCnt=0, TtlEmplyCnt=0, CYRvnsLssExpnssAmt=3123744, TtlLbltsEOYAmt=22864113, TtlLbltsBOYAmt=20379310, TtlAsstsEOYAmt=60511849, TtlAsstsBOYAmt=54569751),\n",
       "  Row(ObjectID='202010729349300021', EIN='344427516', State='OH', Name='TIFFIN UNIVERSITY', Revenue=64789812, TtlVlntrsCnt=16, TtlEmplyCnt=1194, CYRvnsLssExpnssAmt=995667, TtlLbltsEOYAmt=28335011, TtlLbltsBOYAmt=30287043, TtlAsstsEOYAmt=84770678, TtlAsstsBOYAmt=85702921),\n",
       "  Row(ObjectID='202010729349300836', EIN='840865247', State='CO', Name='NETWORK MINISTRIES INC', Revenue=218029, TtlVlntrsCnt=0, TtlEmplyCnt=0, CYRvnsLssExpnssAmt=63859, TtlLbltsEOYAmt=3000, TtlLbltsBOYAmt=2507, TtlAsstsEOYAmt=240903, TtlAsstsBOYAmt=176551),\n",
       "  Row(ObjectID='202000669349300135', EIN='205647589', State='SC', Name='FAMILY PROMISE OF BEAUFORT COUNTY', Revenue=482668, TtlVlntrsCnt=800, TtlEmplyCnt=7, CYRvnsLssExpnssAmt=84363, TtlLbltsEOYAmt=12418, TtlLbltsBOYAmt=13837, TtlAsstsEOYAmt=715271, TtlAsstsBOYAmt=632327)])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Einlesen des Files von HDFS als PysparkDF\n",
    "from pyspark.sql.session import SparkSession\n",
    "spark2 = SparkSession.builder.appName(\"Test1\").getOrCreate()\n",
    "\n",
    "hdfs_path = \"hdfs://big-spark-cluster-m/user/root/184781.parquet\"\n",
    "df = spark2.read.parquet(hdfs_path, header=True, inferSchema=True)\n",
    "\n",
    "type(df), df.printSchema(), df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- State: string (nullable = true)\n",
      " |-- Revenue: integer (nullable = true)\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'CA': 106408523167,\n",
       " 'NY': 91528335932,\n",
       " 'PA': 67741481219,\n",
       " 'TX': 46584829555,\n",
       " 'MO': 35258367904,\n",
       " 'IL': 34193375787,\n",
       " 'FL': 33918087515,\n",
       " 'OH': 32432309967,\n",
       " 'MD': 30846109123,\n",
       " 'MA': 30763181332,\n",
       " 'WI': 26739476181,\n",
       " 'WA': 25497047400,\n",
       " 'NC': 25155248409,\n",
       " 'VA': 25149568077,\n",
       " 'GA': 24111079151,\n",
       " 'NJ': 21603531779,\n",
       " 'DC': 21366864744,\n",
       " 'MN': 21050609165,\n",
       " 'TN': 20017954834,\n",
       " 'IN': 19655247991,\n",
       " 'MI': 17576295804,\n",
       " 'CT': 12753735805,\n",
       " 'IA': 12581959378,\n",
       " 'KY': 12194589121,\n",
       " 'OR': 11416409055,\n",
       " 'AZ': 9392140979,\n",
       " 'CO': 8787348925,\n",
       " 'OK': 8484476755,\n",
       " 'NE': 8057950606,\n",
       " 'NH': 7383333727,\n",
       " 'AR': 7023177618,\n",
       " 'DE': 6852814220,\n",
       " 'AL': 6401678075,\n",
       " 'LA': 6359008465,\n",
       " 'HI': 6264205796,\n",
       " 'KS': 5548599753,\n",
       " 'SC': 5306331753,\n",
       " 'WV': 5238848159,\n",
       " 'RI': 5102848789,\n",
       " 'ME': 4094556969,\n",
       " 'MT': 3909882954,\n",
       " 'NM': 3322449390,\n",
       " 'SD': 3174786870,\n",
       " 'ND': 3016922247,\n",
       " 'XX': 2812601645,\n",
       " 'VT': 2811351956,\n",
       " 'MS': 2591830358,\n",
       " 'UT': 2466648085,\n",
       " 'NV': 2259523194,\n",
       " 'AK': 1763358153,\n",
       " 'ID': 1514337329,\n",
       " 'WY': 748097139,\n",
       " 'PR': 600549770,\n",
       " 'VI': 132915925,\n",
       " 'GU': 481598,\n",
       " 'MP': 283051,\n",
       " 'AP': 157348,\n",
       " '': 0}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Umwandlung in RDD und dann Aufsummierung der Revenues staatenweise\n",
    "from operator import add\n",
    "\n",
    "two_col_df = df.select(\"State\", \"Revenue\") #Reduzierung auf die notwendigen Spalten \n",
    "two_col_df.printSchema()\n",
    "rdd = two_col_df.rdd #Umwandlung in ein Key, Value RDD\n",
    "\n",
    "reduced_rdd = rdd.reduceByKey(add).sortBy(lambda x: x[1], ascending = False) #Aggreation und Sortierung nach Rev\n",
    "state_rev = reduced_rdd.collectAsMap() #Umwandlung in Python Dict\n",
    "state_rev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install cartopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_2453/2602625185.py:17: DeprecationWarning: The background_patch property is deprecated. Use GeoAxes.patch instead.\n",
      "  ax.background_patch.set_visible(False)\n",
      "/tmp/ipykernel_2453/2602625185.py:18: DeprecationWarning: The outline_patch property is deprecated. Use GeoAxes.spines['geo'] or the default Axes properties instead.\n",
      "  ax.outline_patch.set_visible(False)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import rgb2hex, Normalize\n",
    "from matplotlib.colorbar import ColorbarBase\n",
    "from matplotlib import cm\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.io.shapereader as shpreader\n",
    "import numpy as np\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_axes([0, 0, 1, 1], projection=ccrs.LambertConformal())\n",
    "\n",
    "ax.set_extent([-125, -66.5, 20, 50], ccrs.Geodetic())\n",
    "\n",
    "shapename = 'admin_1_states_provinces_lakes'\n",
    "states_shp = shpreader.natural_earth(resolution='110m',\n",
    "                                     category='cultural', name=shapename)\n",
    "ax.background_patch.set_visible(False)\n",
    "ax.outline_patch.set_visible(False)\n",
    "\n",
    "ax.set_title('Revenue summed per state')\n",
    "\n",
    "cmap = cm.get_cmap(\"YlGn\")\n",
    "min_val = min(state_rev.values())\n",
    "max_val = max(state_rev.values())\n",
    "\n",
    "for astate in shpreader.Reader(states_shp).records():\n",
    "\n",
    "    edgecolor = 'black'\n",
    "\n",
    "    try: #Set values of the states depending on the values from our data\n",
    "        rev_one_state = state_rev[ astate.attributes['postal'] ]\n",
    "    except:\n",
    "        rev_one_state = 0\n",
    "\n",
    "    # Add shape with corresponding color\n",
    "    ax.add_geometries([astate.geometry], ccrs.PlateCarree(),\n",
    "                      facecolor=cmap(np.sqrt((rev_one_state-min_val)/(max_val-min_val)))[:3], edgecolor=edgecolor)\n",
    "\n",
    "# Plot Colorbarlegend\n",
    "ax_c = fig.add_axes([0.9, 0.1, 0.03, 0.8])\n",
    "norm = Normalize(vmin=min_val, vmax=max_val)\n",
    "cb = ColorbarBase(ax_c,cmap=cmap,norm=norm,orientation='vertical',\n",
    "                  label='revenue')\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PySpark",
   "language": "python",
   "name": "pyspark"
  },
  "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.8.12"
  },
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}