6. Get city loans summary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import packages and set options (pick city next step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Importing packages...\n",
      "ok\n"
     ]
    }
   ],
   "source": [
    "print('Importing packages...')\n",
    "import os\n",
    "import pandas\n",
    "import numpy as np\n",
    "import time\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import geopandas\n",
    "import scipy.stats\n",
    "#from pprint import pprint\n",
    "import io\n",
    "from shapely.ops import unary_union\n",
    "from shapely.geometry import box, Polygon, LineString, MultiLineString\n",
    "\n",
    "thisdir = '/home/idies/workspace/21cc/raddick/community_reinvestment_act/'\n",
    "data_dir = thisdir + 'city_data/'\n",
    "figdir = thisdir + 'figures/'\n",
    "\n",
    "baltimore_shapefile_basedir = '/home/idies/workspace/Storage/raddick/Baltimore/shapefiles/'\n",
    "census_shapefile_tiger_basedir = '/home/idies/workspace/21cc/Data/Census/Shapefiles/TIGER/'\n",
    "\n",
    "earliest_year = 2012\n",
    "latest_year = 2022\n",
    "\n",
    "check_tract_consistency = True\n",
    "show_water = True\n",
    "\n",
    "# ANALYSIS OPTIONS\n",
    "sb_jobs_lower_limit = 10\n",
    "pop_lower_limit = 1000\n",
    "tol = 8100  # Tolerance for declaring a tract is contained in a city council district\n",
    "summary = {}\n",
    "equal_area_proj = 2163 #{'init': 'epsg:2163'}   # https://epsg.io/2163\n",
    "\n",
    "\n",
    "# MAPPING OPTIONS\n",
    "scale = 1\n",
    "show_tract_labels = False\n",
    "manual_colorbar = True\n",
    "\n",
    "thecolormap = 'Greys'\n",
    "\n",
    "show_water = True\n",
    "no_data_hatch = '/'  # one of {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
    "water_hatch = '|'    # one of {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
    "not_in_city_hatch = 'x'    # one of {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
    "\n",
    "show_plot_labels = True\n",
    "\n",
    "g = 0\n",
    "\n",
    "print('ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pick city"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected Baltimore!\n"
     ]
    }
   ],
   "source": [
    "s = time.time()\n",
    "city = 'Baltimore'\n",
    "\n",
    "# Default values will be changed for specific citites if needed\n",
    "top_of_color_scale = 300000\n",
    "color_scale_tick_interval = 50000\n",
    "color_scale_unit = 'thousand'\n",
    "\n",
    "\n",
    "if (city == 'Cleveland'):\n",
    "    projection = {'init': 'EPSG:3734'}\n",
    "    thestate = 39\n",
    "    top_of_color_scale = 3000000\n",
    "    color_scale_tick_interval = 500000\n",
    "    color_scale_unit = 'million'\n",
    "elif (city == 'Baltimore'):\n",
    "    projection = {'init': 'EPSG:6487'}\n",
    "    thestate = 24\n",
    "    top_of_color_scale = 100000 #450000\n",
    "    color_scale_tick_interval = 20000\n",
    "    color_scale_unit = 'thousand'\n",
    "    #color_scale_tick_interval = 50000    \n",
    "elif (city == 'Washington D.C.'):\n",
    "    #projection = {'init': 'EPSG:6487'}\n",
    "    projection = {'init': 'EPSG:3857'}\n",
    "    thestate = 11\n",
    "elif (city == 'Detroit'):\n",
    "    projection = {'init': 'EPSG:2253'}\n",
    "    thestate = 26\n",
    "    top_of_color_scale = 900000\n",
    "    color_scale_tick_interval = 100000\n",
    "elif (city == 'Philadelphia'):\n",
    "    thestate = 42\n",
    "    projection = {'init': 'EPSG:2272'}\n",
    "    top_of_color_scale = 400000\n",
    "    color_scale_tick_interval = 50000\n",
    "elif (city == 'Pittsburgh'):\n",
    "    thestate = 42\n",
    "    projection = {'init': 'EPSG:2272'}\n",
    "    top_of_color_scale = 350000\n",
    "    color_scale_itck_interval = 50000\n",
    "elif (city == 'St. Louis'):\n",
    "    thestate = 29\n",
    "    projection = {'init': 'EPSG:6512'}\n",
    "    top_of_color_scale = 350000\n",
    "    color_scale_tick_interval = 50000\n",
    "    \n",
    "elif (city == 'Newark'):\n",
    "    thestate = 34\n",
    "    projection = {'init': 'EPSG:3424'}\n",
    "    top_of_color_scale = 350000\n",
    "    color_scale_itck_interval = 50000\n",
    "\n",
    "else:\n",
    "    print('Pick a city. Possible values:\\n\\tBaltimore, Washington D.C., Detroit, Newark, St. Louis, Richmond, San Francisco, Cleveland, Philadelphia, Pittsburgh\\n')\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "print('Selected {0:}!'.format(city)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process to make a dataframe we can map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get raw data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading numerical data...\n",
      "Getting shapefiles...\n",
      "\t2022...\n",
      "\t2021...\n",
      "\t2020...\n",
      "\t2019...\n",
      "\t2018...\n",
      "\t2017...\n",
      "\t2016...\n",
      "\t2015...\n",
      "\t2014...\n",
      "\t2013...\n",
      "\t2012...\n",
      "Read 2,194 rows by 381 columns in 8.1 seconds!\n"
     ]
    }
   ],
   "source": [
    "# # BALTIMORE: Starting in 2020, census tracts 1801 and 1802 were combined into 2806\n",
    "\n",
    "s = time.time()\n",
    "print('loading numerical data...')\n",
    "city_name_parsed = city.replace(\".\",\"\").replace(\" \",\"_\").lower()\n",
    "raw_data_df = pandas.read_csv(data_dir+'{0:}_{1:.0f}_{2:.0f}_year_by_year.csv'.format(city_name_parsed, earliest_year, latest_year))\n",
    "raw_data_df = raw_data_df.set_index(['GEOID', 'year'])\n",
    "\n",
    "#raw_data_df = raw_data_df.drop(['county.1', 'census_tract.1'], axis=1)  # drop duplicate columns\n",
    "\n",
    "# # print('\\n')\n",
    "# # e = time.time()\n",
    "# # g = g + (e-s)\n",
    "\n",
    "# # #print('Read {0:,.0f} rows by {1:,.0f} columns in {2:,.1f} seconds!'.format(raw_data_df.shape[0], raw_data_df.shape[1], e-s))\n",
    "\n",
    "print('Getting shapefiles...')\n",
    "theyears = raw_data_df.index.get_level_values('year').drop_duplicates().sort_values(ascending=False).tolist()\n",
    "\n",
    "shapefiles_gdf = geopandas.GeoDataFrame()\n",
    "for thisyear in theyears:\n",
    "    print('\\t{0:.0f}...'.format(thisyear))\n",
    "    thisfile = '{0:}{1:.0f}/TRACT/tl_{1:.0f}_{2:02d}_tract.shp'.format(census_shapefile_tiger_basedir, thisyear, thestate)\n",
    "    gdfi = geopandas.read_file(thisfile)\n",
    "    gdfi = gdfi[gdfi['COUNTYFP'] == '510']  # Baltimore City\n",
    "    gdfi = gdfi.assign(year = thisyear)\n",
    "    gdfi.loc[:, 'GEOID'] = gdfi['GEOID'].apply(lambda x: '14000US'+x)\n",
    "    this_year_geoid_list = raw_data_df.xs(thisyear, level='year').sort_index().index.tolist()\n",
    "    gdfi = gdfi[gdfi['GEOID'].isin(this_year_geoid_list)]\n",
    "    shapefiles_gdf = pandas.concat((shapefiles_gdf, gdfi), axis=0)\n",
    "shapefiles_gdf = shapefiles_gdf.set_index(['GEOID', 'year'])\n",
    "\n",
    "\n",
    "\n",
    "# print('backing up...')\n",
    "# raw_data_df_bk = raw_data_df\n",
    "# shapefiles_gdf_bk = shapefiles_gdf\n",
    "\n",
    "e = time.time()\n",
    "g += e-s\n",
    "\n",
    "print('Read {0:,.0f} rows by {1:,.0f} columns in {2:,.1f} seconds!'.format(raw_data_df.shape[0], raw_data_df.shape[1]+shapefiles_gdf.shape[1], e-s))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Which census tracts changed, when?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many tracts per year?\n",
      "\t2012: found 200 tracts!\n",
      "\t2013: found 200 tracts!\n",
      "\t2014: found 200 tracts!\n",
      "\t2015: found 200 tracts!\n",
      "\t2016: found 200 tracts!\n",
      "\t2017: found 200 tracts!\n",
      "\t2018: found 200 tracts!\n",
      "\t2019: found 200 tracts!\n",
      "\t2020: found 198 tracts!\n",
      "\t2021: found 198 tracts!\n",
      "\t2022: found 198 tracts!\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x1296 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In 2020 but not in 2019:  []\n",
      "In 2019 but not in 2020:  ['14000US24510180100', '14000US24510180200']\n"
     ]
    }
   ],
   "source": [
    "# print('getting from backup...')\n",
    "# raw_data_df = pandas.DataFrame()\n",
    "# shapefiles_gdf = pandas.DataFrame()\n",
    "\n",
    "# raw_data_df = raw_data_df_bk\n",
    "# shapefiles_gdf = shapefiles_gdf_bk\n",
    "xlim = [-76.65,-76.6]\n",
    "ylim = [39.275,39.3]\n",
    "plot_geo = box(xlim[0], ylim[0], xlim[1], ylim[1])\n",
    "\n",
    "\n",
    "print('How many tracts per year?')\n",
    "theyears = shapefiles_gdf.index.get_level_values(level='year').drop_duplicates().sort_values().tolist()\n",
    "for thisyear in theyears:\n",
    "    print('\\t{0:}: found {1:,.0f} tracts!'.format(thisyear, len(shapefiles_gdf.xs(thisyear, level='year'))))\n",
    "\n",
    "\n",
    "tracts_2019_gdf = shapefiles_gdf.xs(2019, level='year')\n",
    "tracts_2020_gdf = shapefiles_gdf.xs(2020, level='year')\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize=(18,18))\n",
    "tracts_2019_gdf.plot(ax=ax, color='none', edgecolor='black')\n",
    "tracts_2020_gdf.plot(ax=ax, color='none', edgecolor='red')\n",
    "\n",
    "\n",
    "for ix, thisrow in tracts_2019_gdf[tracts_2019_gdf.geometry.apply(lambda x: x.intersects(plot_geo))].iterrows():\n",
    "    annotator = '{0:}'.format(thisrow['NAME'])\n",
    "    ax.annotate(annotator, \n",
    "                (thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "                (thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "               color='black')\n",
    "for ix, thisrow in tracts_2020_gdf[tracts_2020_gdf.geometry.apply(lambda x: x.intersects(plot_geo))].iterrows():\n",
    "    annotator = '{0:}'.format(thisrow['NAME'])\n",
    "    ax.annotate(annotator, \n",
    "                (thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "                (thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "               color='red')\n",
    "    \n",
    "\n",
    "ax.set_xlim(xlim)\n",
    "ax.set_ylim(ylim)\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "tracts_2020_but_not_2019 = tracts_2020_gdf[~tracts_2020_gdf.index.isin(tracts_2019_gdf.index.tolist())].index.tolist()\n",
    "tracts_2019_but_not_2020 = tracts_2019_gdf[~tracts_2019_gdf.index.isin(tracts_2020_gdf.index.tolist())].index.tolist()\n",
    "\n",
    "print('In 2020 but not in 2019: ', tracts_2020_but_not_2019)\n",
    "print('In 2019 but not in 2020: ', tracts_2019_but_not_2020)\n",
    "\n",
    "# 2010 Census: Poppelton was tracts 1801.00 and 1802.00\n",
    "# 2020 Census: Poppelton is tract 2806.00\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get summary info for tracts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create empty dataframe with 2020 tracts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating summary data frame...\n",
      "Baltimore: adding census tract 2806.00 (combined 1801.00/1901.00 starting in 2020)...\n",
      "Got 199 modern tracts in 0.0 seconds!\n"
     ]
    }
   ],
   "source": [
    "s = time.time()\n",
    "print('creating summary data frame...')\n",
    "tract_ix = shapefiles_gdf.xs(latest_year, level='year').sort_index().index\n",
    "\n",
    "if (city == 'Baltimore'):\n",
    "    print('Baltimore: adding census tract 2806.00 (combined 1801.00/1901.00 starting in 2020)...')\n",
    "    tract_ix = tract_ix.union(['14000US24510280600'])\n",
    "\n",
    "data_df = pandas.DataFrame(data=None, index=tract_ix)\n",
    "data_df.index.name = 'GEOID'\n",
    "\n",
    "e = time.time()\n",
    "g += e-s\n",
    "print('Got {0:,.0f} modern tracts in {1:,.1f} seconds!'.format(data_df.shape[0], e-s))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find each tract's total loans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# print('adding tract and loan info columns...')\n",
    "# info_columns = ['state', 'county', 'census_tract', 'city_name', 'msa', 'loan_type', 'action_taken_type']\n",
    "# data_df = data_df.join(raw_data_df.xs(latest_year, level='year')[info_columns], how='outer')\n",
    "\n",
    "print('summing loan columns...')\n",
    "sum_columns = []\n",
    "sum_columns += ['nLoans1', 'amtLoans1_adj', 'nLoans100k', 'amtLoans100k_adj', 'nLoans250k', 'amtLoans250k_adj']\n",
    "sum_columns += ['nLoansToSmallest', 'amtLoansToSmallest_adj', 'nLoans', 'amtLoans_adj']\n",
    "sum_columns += ['nWorkingLoans', 'amtWorkingLoans_adj']\n",
    "sum_columns += ['nLoans1_per_totaljob', 'amtLoans1_per_totaljob_adj']\n",
    "sum_columns += ['nLoans100k_per_totaljob', 'amtLoans100k_per_totaljob_adj']\n",
    "sum_columns += ['nLoans250k_per_totaljob', 'amtLoans250k_per_totaljob_adj']\n",
    "sum_columns += ['nLoansToSmallest_per_totaljob', 'amtLoansToSmallest_per_totaljob_adj']\n",
    "sum_columns += ['nLoans_per_totaljob', 'amtLoans_per_totaljob_adj']\n",
    "sum_columns += ['nWorkingLoans_per_totaljob', 'amtWorkingLoans_per_totaljob_adj']\n",
    "sum_columns += ['nLoans1_per_sbjob', 'amtLoans1_per_sbjob_adj']\n",
    "sum_columns += ['nLoans100k_per_sbjob', 'amtLoans100k_per_sbjob_adj']\n",
    "sum_columns += ['nLoans250k_per_sbjob', 'amtLoans250k_per_sbjob_adj']\n",
    "sum_columns += ['nLoansToSmallest_per_sbjob', 'amtLoansToSmallest_per_sbjob_adj']\n",
    "sum_columns += ['nLoans_per_sbjob', 'amtLoans_per_sbjob_adj']\n",
    "sum_columns += ['nWorkingLoans_per_sbjob', 'amtWorkingLoans_per_sbjob_adj']\n",
    "data_df = data_df.join(raw_data_df.xs(latest_year, level='year')[sum_columns], how='left')\n",
    "\n",
    "\n",
    "e = time.time()\n",
    "g += e-s\n",
    "print('Summarized {0:,.0f} variables for {1:,.0f} all-years-tracts in {2:,.1f} seconds!'.format(data_df.shape[1], data_df.shape[0], e-s))\n",
    "#data_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add CRA info and jobs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print('getting from backup...')\n",
    "# data_df = pandas.DataFrame()\n",
    "# data_df = data_df_bk\n",
    "s = time.time()\n",
    "\n",
    "print('adding CRA info columns...')\n",
    "cra_info_columns = ['income_group_code', 'income_group', 'cra_level']\n",
    "\n",
    "data_df = data_df.join(raw_data_df.xs(latest_year, level='year')[cra_info_columns], how='outer')\n",
    "\n",
    "for thiscol in cra_info_columns:\n",
    "    data_df = data_df.rename(columns={thiscol: '{0:}_{1:.0f}'.format(thiscol, latest_year)})\n",
    "\n",
    "print('adding jobs columns...')\n",
    "\n",
    "jobs_columns = []\n",
    "jobs_columns += ['total_jobs', 'sb_jobs', 'C000', 'CA01', 'CA02', 'CA03']\n",
    "jobs_columns += ['CE01', 'CE02', 'CE03', 'CNS01', 'CNS02', 'CNS03', 'CNS04', 'CNS05']\n",
    "jobs_columns += ['CNS06', 'CNS07', 'CNS08', 'CNS09', 'CNS10', 'CNS11', 'CNS12']\n",
    "jobs_columns += ['CNS13', 'CNS14', 'CNS15', 'CNS16', 'CNS17', 'CNS18', 'CNS19', 'CNS20']\n",
    "jobs_columns += ['CR01', 'CR02', 'CR03', 'CR04', 'CR05', 'CR07', 'CT01', 'CT02']\n",
    "jobs_columns += ['CD01', 'CD02', 'CD03', 'CD04', 'CS01', 'CS02']\n",
    "jobs_columns += ['CFA01', 'CFA02', 'CFA03', 'CFA04', 'CFA05']\n",
    "jobs_columns += ['CFS01', 'CFS02', 'CFS03', 'CFS04', 'CFS05']\n",
    "\n",
    "data_df = data_df.join(raw_data_df.xs(latest_year, level='year')[jobs_columns], how='outer')\n",
    "\n",
    "e = time.time()\n",
    "g += e-s\n",
    "print('Summarized {0:,.0f} variables for {1:,.0f} all-years-tracts in {2:,.1f} seconds!'.format(data_df.shape[1], data_df.shape[0], e-s))\n",
    "\n",
    "data_df\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "[x for x in raw_data_df.columns.tolist() if x not in data_df.columns.tolist()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# print('\\n')\n",
    "# print('Tracts with data but no shapefiles...')\n",
    "# print(data_df[data_df['state'].isnull()].index.tolist())\n",
    "# print('\\n')\n",
    "# print('Tracts with shapefiles but no data...')\n",
    "# print(data_df[data_df['nLoans1'].isnull()].index.tolist())\n",
    "# print('\\n')\n",
    "\n",
    "# # # # # #data_df.loc['14000US24510280600']\n",
    "# # # # # data_columns = data_df.columns[3:]\n",
    "# # # # # #for thiscol in data_columns:\n",
    "\n",
    "# # # # # data_df[sum_columns].loc[['14000US24510180100', '14000US24510180200']]\n",
    "# # # # raw_data_df[sum_columns]\n",
    "# # # pre_2020_tracts = ['14000US24510180100', '14000US24510180200']\n",
    "# # # post_2020_tracts = ['14000US24510280600']\n",
    "\n",
    "# # # # raw_data_df\n",
    "# # # raw_data_df[raw_data_df.index.get_level_values('GEOID').isin(post_2020_tracts)][sum_columns]\n",
    "# # # #data_df[data_df.index.isin(post_2020_tracts)]\n",
    "# # # # for ix, thisrow in raw_data_df[raw_data_df.index.get_level_values('GEOID').isin(['14000US24510180100', '14000US24510180200'])][sum_columns].reset_index().groupby('year').sum().iterrows():\n",
    "# # # #     for thiscol in sum_columns:\n",
    "# # # #         data_df.loc[()]\n",
    "\n",
    "\n",
    "# # # #data_df.loc[~data_df.index.isin(post_2020_tracts)] = \n",
    "\n",
    "\n",
    "\n",
    "# # # for thiscol in sum_columns:\n",
    "# # #     data_df[thiscol] = np.nan\n",
    "# # #     data_df.loc[~data_df.index.isin(post_2020_tracts), thiscol] = raw_data_df.reset_index()[~raw_data_df.reset_index()['GEOID'].isin(pre_2020_tracts)].groupby('GEOID')[thiscol].sum()\n",
    "# # #     #for ix in post_2020_tracts:\n",
    "# # #     print(thiscol)\n",
    "# # #     #print(raw_data_df[raw_data_df.index.get_level_values('GEOID').isin(['14000US24510180100', '14000US24510180200'])][thiscol].reset_index().groupby('year').sum())\n",
    "    \n",
    "# # # #data_df\n",
    "\n",
    "# # # raw_data_df.reset_index()[raw_data_df.reset_index()['GEOID'].isin(pre_2020_tracts)]\n",
    "# # #raw_data_df[raw_data_df['census_tract'] == 2806]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "# # census count errors\n",
    "# new_columns = []\n",
    "# new_columns += ['pop_total_err','pop_by_race_total_err','pop_white_err','pop_black_err']\n",
    "# new_columns += ['total_households_err','white_householders_err','black_householders_err','female_householders_err']\n",
    "# new_columns += ['total_housing_units_err','occupied_housing_units_err','vacant_housing_units_err']\n",
    "# new_columns += ['educated_serr','unemployed_16plus_err','poverty_past_12_months_err','mfi_err'] # high school graduates (ages 25+), unemployed, in poverty, MFI, travel time to work\n",
    "# new_columns += ['owner_occ_housing_units_err','median_home_value_err', 'median_year_built_err'] # home\n",
    "# new_columns += ['pop_25plus_err','labor_force_16plus_err','poverty_status_known_err']\n",
    "\n",
    "# # census percentages and their errors\n",
    "# new_columns += ['pct_white','pct_black','pct_white_householders','pct_black_householders','pct_female_householders']\n",
    "# new_columns += ['peducated','pct_unemployed','pct_poverty','pct_vacant', 'pct_household_familiy', 'pct_rent']\n",
    "# new_columns += ['pct_white_serr','pct_black_serr','pct_white_householders_serr','pct_black_householders_serr','pct_female_householders_serr']\n",
    "# new_columns += ['peducated_serr','pct_unemployed_serr','pct_poverty_serr','pct_vacant_serr', 'pct_household_familiy_serr', 'pct_rent_serr']\n",
    "# new_columns += ['household_type_family_err', 'household_type_nonfamily_err', 'household_type_total_err', 'tenure_rent_err', 'tenure_total_err']\n",
    "\n",
    "\n",
    "# print('adding demographics...')\n",
    "\n",
    "# demographics_columns = []\n",
    "# demographics_columns += ['pop_total', 'pop_by_race_total', 'pop_white', 'pop_black']\n",
    "# demographics_columns += ['total_households', 'white_householders', 'black_householders', 'female_householders']\n",
    "# demographics_columns += ['total_housing_units', 'occupied_housing_units', 'vacant_housing_units']\n",
    "# demographics_columns += ['educated', 'unemployed_16plus', 'poverty_past_12_months', 'mfi_adj']\n",
    "# demographics_columns += ['owner_occ_housing_units', 'median_home_value', 'year_built', 'median_year_built']\n",
    "# demographics_columns += ['pop_25plus', 'labor_force_16plus', 'poverty_status_known']\n",
    "# demographics_columns += ['household_type_family', 'household_type_nonfamily', 'household_type_total', 'tenure_rent', 'tenure_total']\n",
    "\n",
    "# demographics_columns += ['pop_total_err', 'pop_by_race_total_err', 'pop_white_err', 'pop_black_err']\n",
    "# demographics_columns += ['total_households_err', 'white_householders_err', 'black_householders_err', 'female_householders_err']\n",
    "# demographics_columns += ['total_housing_units_err', 'occupied_housing_units_err', 'vacant_housing_units_err']\n",
    "# demographics_columns += ['educated_serr', 'unemployed_16plus_err', 'poverty_past_12_months_err', 'mfi_err']\n",
    "# demographics_columns += ['owner_occ_housing_units_err', 'median_home_value_err', 'pop_25plus_err', 'labor_force_16plus_err', 'poverty_status_known_err']\n",
    "# demographics_columns += ['household_type_family_err', 'household_type_nonfamily_err', 'household_type_total_err', 'tenure_rent_err', 'tenure_total_err']\n",
    "\n",
    "# demographics_columns += ['pct_white', 'pct_black']\n",
    "# demographics_columns += ['pct_white_householders', 'pct_black_householders', 'pct_female_householders']\n",
    "# demographics_columns += ['peducated', 'pct_unemployed', 'pct_poverty', 'pct_vacant']\n",
    "# demographics_columns += ['pct_white_serr', 'pct_black_serr']\n",
    "# demographics_columns += ['pct_white_householders_serr', 'pct_black_householders_serr', 'pct_female_householders_serr']\n",
    "# demographics_columns += ['peducated_serr', 'pct_unemployed_serr', 'pct_poverty_serr', 'pct_vacant_serr']\n",
    "# demographics_columns += ['pct_household_family', 'pct_rent', 'pct_household_family_serr', 'pct_rent_serr']\n",
    "# data_df = pandas.concat((data_df, raw_data_df[demographics_columns].xs(latest_year, level='year')), axis=1)\n",
    "\n",
    "# for thiscol in demographics_columns:\n",
    "#     data_df = data_df.rename(columns = {thiscol: thiscol+'_{0:.0f}'.format(latest_year)})\n",
    "\n",
    "# geo_info_columns = []\n",
    "# # if (city == 'Baltimore'):\n",
    "# #     geo_info_columns += ['split_county_indicator', 'population_classification', 'CSA2020']\n",
    "# # else:\n",
    "# geo_info_columns += ['split_county_indicator', 'population_classification']\n",
    "# geo_info_columns += ['NAMELSAD', 'MTFCC', 'FUNCSTAT']\n",
    "# geo_info_columns += ['ALAND', 'AWATER', 'INTPTLAT', 'INTPTLON']\n",
    "\n",
    "# data_df = pandas.concat((data_df, raw_data_df[geo_info_columns].xs(latest_year, level='year')), axis=1)\n",
    "\n",
    "# for thiscol in geo_info_columns:\n",
    "#     data_df = data_df.rename(columns = {thiscol: thiscol+'_{0:.0f}'.format(latest_year)})\n",
    "\n",
    "# data_df = data_df.assign(geometry = None)\n",
    "\n",
    "\n",
    "\n",
    "# data_df.loc[:, 'geometry'] = shapefiles_gdf.xs(latest_year, level='year')['geometry'].tolist()\n",
    "# data_gdf = geopandas.GeoDataFrame(data_df, crs=shapefiles_gdf.crs, geometry='geometry')\n",
    "\n",
    "# # # if (city == 'Baltimore'):\n",
    "# # #     baltimore_shapefiles_gdf = baltimore_shapefiles_gdf.to_crs(tracts_included_gdf.crs)\n",
    "\n",
    "# e = time.time()\n",
    "# g = g + (e-s)\n",
    "\n",
    "# print('\\nDone in {0:,.1f} seconds!'.format(e-s))\n",
    "\n",
    "# # shapefiles_gdf.index#.shape   # 1996\n",
    "\n",
    "# data_gdf.index.name = 'GEOID'\n",
    "\n",
    "# # #data_df#[~data_df.index.isin(shapefiles_gdf.index.get_level_values(0))]\n",
    "\n",
    "# # #shapefiles_gdf.xs(2020, level='year')\n",
    "# data_gdf\n",
    "# #data_df[data_df['state'].isnull()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read water area shapefiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "show_water = True\n",
    "if (show_water):\n",
    "    print('reading water files...')\n",
    "    water_dir = census_shapefile_tiger_basedir+\"{0:.0f}/AREAWATER/{1:}/\".format(latest_year, 'md')\n",
    "    water_files = [water_dir+x for x in os.listdir(water_dir) if ('tl_{0:.0f}_{1:02d}'.format(latest_year,thestate) in x) and (x[-3:] == 'shp')]\n",
    "    \n",
    "    water_gdf = geopandas.GeoDataFrame()\n",
    "    for i in range(0, len(water_files)):\n",
    "        if ((np.mod(i,10) == 0) | (i == len(water_files)-1)):\n",
    "            print('\\treading water file {0:,.0f} of {1:,.0f}...'.format(i+1, len(water_files)))\n",
    "        water_gdf = pandas.concat((water_gdf, geopandas.read_file(water_files[i])))\n",
    "    water_gdf = water_gdf.to_crs(data_gdf.crs)\n",
    "    print('\\tfinding water within city...')\n",
    "    city_water_gdf = geopandas.overlay(water_gdf, geopandas.GeoDataFrame(data=[[unary_union(data_gdf.geometry.tolist())]], columns=['geometry'], crs=data_gdf.crs, geometry='geometry'), how='intersection')\n",
    "\n",
    "    if (city == 'Baltimore'):\n",
    "        #city_water_gdf.plot(ax=ax, color='orange')\n",
    "        #print(city_water_gdf.loc[city_water_gdf.to_crs(equal_area_proj).geometry.area.apply(lambda x: x / (1000*1000)).sort_values(ascending=False).index.tolist()])\n",
    "        baltimore_water_gdf = city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'hbr' in str(x).lower())]#.plot(ax=ax, color='cyan')                \n",
    "        baltimore_water_gdf = pandas.concat((baltimore_water_gdf, city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'patapsco' in str(x).lower())]), axis=0, sort=False)#.plot(ax=ax, color='cyan')\n",
    "        baltimore_water_gdf = pandas.concat((baltimore_water_gdf, city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'curtis' in str(x).lower())]), axis=0, sort=False)#.plot(ax=ax, color='cyan')\n",
    "        baltimore_water_gdf = pandas.concat((baltimore_water_gdf, city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'colgate' in str(x).lower())]), axis=0, sort=False)#.plot(ax=ax, color='cyan')\n",
    "        baltimore_water_gdf = pandas.concat((baltimore_water_gdf, city_water_gdf[city_water_gdf['HYDROID'] == '110190589339']), axis=0, sort=False)#.plot(ax=ax, color='cyan')   # Inner Harbor\n",
    "        baltimore_water_gdf = pandas.concat((baltimore_water_gdf, city_water_gdf[city_water_gdf['HYDROID'].isin(['110190589337','110190589300'])]), axis=0, sort=False)#.plot(ax=ax, color='cyan')   # Two other spots in the harbor\n",
    "        city_water_gdf = baltimore_water_gdf\n",
    "    elif (city == 'Washington D.C.'):\n",
    "        city_water_gdf = city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: ('potomac' in str(x).lower()) | ('anacostia' in str(x).lower()) | ('washington chnnl' in str(x).lower()))]#.plot(ax=ax, color='cyan')\n",
    "    elif (city == 'Cleveland'):\n",
    "        city_water_gdf = city_water_gdf.loc[city_water_gdf.to_crs(epsg=equal_area_proj).geometry.area.sort_values(ascending=False).head(3).index.tolist()]\n",
    "    elif (city == 'Detroit'):\n",
    "        detroit_water_gdf = city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'riv' in str(x).lower())]\n",
    "        detroit_water_gdf = pandas.concat((detroit_water_gdf, city_water_gdf[city_water_gdf['HYDROID'].isin(['1107295328725','1107295323725'])]), axis=0, sort=False)\n",
    "        city_water_gdf = detroit_water_gdf\n",
    "    elif (city == 'Philadelphia'):\n",
    "        philadelphia_water_gdf = city_water_gdf[\n",
    "            city_water_gdf['FULLNAME'].apply(lambda x: (str(x).lower()[-3:] == 'riv') | (str(x).lower()[-3:] == 'crk')) \n",
    "        ]\n",
    "        philadelphia_water_gdf = pandas.concat((philadelphia_water_gdf, city_water_gdf[city_water_gdf['HYDROID'].isin(['110687646436','110687646470','1103689733768','1103017430436',])]), axis=0, sort=False)\n",
    "        city_water_gdf = philadelphia_water_gdf\n",
    "    elif (city == 'Pittsburgh'):\n",
    "        city_water_gdf = city_water_gdf[\n",
    "            city_water_gdf['FULLNAME'].apply(lambda x: str(x).lower()[-3:] == 'riv') \n",
    "        ]\n",
    "    elif (city == 'St. Louis'):\n",
    "        city_water_gdf = city_water_gdf[(city_water_gdf['FULLNAME'] == 'Mississippi Riv') | (city_water_gdf['FULLNAME'] == 'River Des Peres')]\n",
    "    else:\n",
    "        pass\n",
    "else:\n",
    "    print('not showing water in this script; to show water, set show_water = True')\n",
    "\n",
    "print('backing up all geodataframes...')\n",
    "data_gdf_bk = data_gdf\n",
    "# tracts_included_gdf_bk = tracts_included_gdf\n",
    "# if (city == 'Baltimore'):\n",
    "#    baltimore_shapefiles_gdf_bk = baltimore_shapefiles_gdf\n",
    "#city_water_gdf_bk = city_water_gdf\n",
    "\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "\n",
    "print('Done in {0:,.1f} seconds!'.format(e-s))\n",
    "\n",
    "# # for ix, thisrow in city_water_gdf.iterrows():\n",
    "# #     ax.annotate(thisrow['HYDROID'], \n",
    "# #                  xy=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "# #                  xytext=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y),\n",
    "# #                 backgroundcolor='white'\n",
    "# #                 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# thecolormap = 'magma'\n",
    "# # xmin = 2660000\n",
    "# # xmax = 2670000\n",
    "# # ymin = 200000\n",
    "# # ymax = 220000\n",
    "\n",
    "# print('getting from backup...')\n",
    "# # all_tracts_gdf = all_tracts_gdf_bk\n",
    "# # tracts_included_gdf = tracts_included_gdf_bk\n",
    "# #city_water_gdf = city_water_gdf_bk\n",
    "\n",
    "# fig, ax = plt.subplots(1,1,figsize=(24*scale,24*scale))\n",
    "# #data_gdf.plot(ax=ax, color='pink', linewidth=2*scale)\n",
    "# #tracts_included_gdf.plot(ax=ax, column='amtWorkingLoans_per_sbjob_adj', cmap=thecolormap, edgecolor='white', linewidth=2*scale)\n",
    "# data_gdf.plot(ax=ax, column='amtWorkingLoans_per_sbjob_adj', cmap=thecolormap, edgecolor='white', linewidth=2*scale)\n",
    "\n",
    "# city_water_gdf.plot(ax=ax, color='orange')\n",
    "# #city_water_gdf[(city_water_gdf['FULLNAME'] == 'Mississippi Riv') | (city_water_gdf['FULLNAME'] == 'River Des Peres')].plot(ax=ax, color='cyan')\n",
    "\n",
    "\n",
    "# plt.show()\n",
    "# # city_water_gdf.loc[\n",
    "# #     city_water_gdf.to_crs(epsg=equal_area_proj).geometry.area.apply(lambda x: x / (1000*1000)).sort_values(ascending=False).head(2).index.tolist()\n",
    "# # ]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# city_water_gdf.plot(ax=ax, color='cyan')\n",
    "\n",
    "# # city_water_gdf[\n",
    "# #             city_water_gdf['FULLNAME'].apply(lambda x: str(x).lower()[-3:] == 'riv') \n",
    "# #         ].plot(ax=ax, color='cyan')\n",
    "\n",
    "# # city_water_gdf.loc[\n",
    "# #     city_water_gdf.to_crs(equal_area_proj).geometry.area.apply(lambda x: x / (1000*1000)).sort_values(ascending=False).head(8).index.tolist()\n",
    "# # ].plot(ax=ax, color='cyan')\n",
    "\n",
    "\n",
    "# #city_water_gdf.plot(ax=ax, color='cyan')\n",
    "\n",
    "\n",
    "# # u = []\n",
    "# # for ix, thisrow in city_water_gdf.iterrows():\n",
    "# # #     print(thisrow.geometry.centroid.coords[0][0])\n",
    "# # #     print(thisrow.geometry.centroid.coords[0][1])\n",
    "# # #     print('\\n')\n",
    "# #     if (((thisrow.geometry.centroid.coords[0][0] >= xmin) & (thisrow.geometry.centroid.coords[0][0] <= xmax)) & ((thisrow.geometry.centroid.coords[0][1] >= ymin) & (thisrow.geometry.centroid.coords[0][1] <= ymax))):\n",
    "# #         ax.annotate(thisrow['HYDROID'], \n",
    "# #                      xy=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "# #                      xytext=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y),\n",
    "# #                     backgroundcolor='white'\n",
    "# #                     )\n",
    "# #         u.append(thisrow['HYDROID'])\n",
    "# # plt.xlim([xmin,xmax])\n",
    "# # plt.ylim([ymin,ymax])\n",
    "# plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# city_water_gdf.loc[\n",
    "#     city_water_gdf.to_crs(equal_area_proj).geometry.area.apply(lambda x: x / (1000*1000)).sort_values(ascending=False).index.tolist()\n",
    "# ]\n",
    "\n",
    "# #city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: (str(x).lower()[-3:] == 'riv') | (str(x).lower()[-3:] == 'crk'))]\n",
    "# #u\n",
    "print('ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find city enclaves and exclaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "union_gdf = geopandas.GeoDataFrame(data=[[unary_union(data_gdf.geometry.tolist())]], columns=['geometry'], crs=data_gdf.crs, geometry='geometry')\n",
    "\n",
    "if (len(union_gdf.geometry.boundary) == 1):\n",
    "    print('no enclaves or exclaves!')\n",
    "print('ok')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# union_gdf = geopandas.GeoDataFrame(unary_union(all_tracts_gdf.geometry.tolist()), columns=['geometry'], crs=all_tracts_gdf.crs, geometry='geometry')\n",
    "\n",
    "# boundary_raw_gdf = geopandas.GeoDataFrame(data=union_gdf.geometry.boundary, columns=['geometry'], crs=union_gdf.crs, geometry='geometry')\n",
    "\n",
    "# boundary_list = []\n",
    "# #boundary_gdf = geopandas.GeoDataFrae(data=None, columns=['geometry'], crs=boundary_raw_gdf.crs, geometry='geometry')\n",
    "\n",
    "\n",
    "# for ix, thisrow in boundary_raw_gdf.iterrows():\n",
    "#     if (thisrow.geometry.type == 'MultiLineString'):\n",
    "#         boundary_list = boundary_list + [x for x in thisrow.geometry.simplify(tolerance = 100)]\n",
    "#     else:\n",
    "#         boundary_list.append(thisrow.geometry)\n",
    "\n",
    "# city_boundary_parts_gdf = geopandas.GeoDataFrame(data=[Polygon(x) for x in boundary_list], columns=['geometry'], crs=union_gdf.crs, geometry='geometry')\n",
    "\n",
    "# city_boundary_parts_gdf = city_boundary_parts_gdf.assign(area = city_boundary_parts_gdf.geometry.apply(lambda x: x.area))\n",
    "\n",
    "# city_boundary_parts_gdf = city_boundary_parts_gdf.sort_values(by='area', ascending=False).reset_index(drop=True)\n",
    "\n",
    "# city_boundary_parts_gdf = city_boundary_parts_gdf.assign(thetype = np.nan)\n",
    "\n",
    "# city_boundary_parts_gdf.loc[0, 'thetype'] = 'main'\n",
    "# main_city_geo = city_boundary_parts_gdf[city_boundary_parts_gdf['thetype'] == 'main'].geometry.values[0]\n",
    "\n",
    "\n",
    "# city_boundary_parts_gdf.loc[\n",
    "#     (\n",
    "#         (city_boundary_parts_gdf['thetype'].isnull()) \n",
    "#         & (city_boundary_parts_gdf.geometry.apply(lambda x: x.within(main_city_geo)))\n",
    "#     ), 'thetype'] = 'enclave'\n",
    "\n",
    "# city_boundary_parts_gdf.loc[\n",
    "#     (\n",
    "#         (city_boundary_parts_gdf['thetype'].isnull()) \n",
    "#         & (~city_boundary_parts_gdf.geometry.apply(lambda x: x.within(main_city_geo)))\n",
    "#     ), 'thetype'] = 'exclave'\n",
    "\n",
    "# # #city_boundary_parts_gdf.loc[city_boundary_parts_gdf[city_boundary_parts_gdf['thetype'] != 'main'].geometry.apply(lambda x: not(x.within(main_city_geo))), 'thetype'] = 'exclave'\n",
    "\n",
    "# # fig, ax = plt.subplots(1,1)\n",
    "\n",
    "# # union_gdf.plot(ax=ax, color='pink')\n",
    "# # #all_tracts_gdf.plot(ax=ax, color='none', edgecolor='black')\n",
    "# # #city_boundary_parts_gdf[city_boundary_parts_gdf['thetype'] == 'enclave'].plot(ax=ax, color='cyan', alpha=0.5)\n",
    "\n",
    "# # plt.show()\n",
    "# print(city_boundary_parts_gdf)#[city_boundary_parts_gdf['thetype'] == 'enclave']\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,1,figsize=(24*scale,24*scale))\n",
    "shapefiles_gdf.plot(ax=ax, color='pink')\n",
    "#tracts_included_gdf.plot(ax=ax, column='amtWorkingLoans_per_sbjob_adj', cmap=thecolormap, edgecolor='white', linewidth=2*scale)\n",
    "data_gdf.plot(ax=ax, column='amtWorkingLoans_per_sbjob_adj', cmap=thecolormap, edgecolor='white', linewidth=2*scale)\n",
    "\n",
    "\n",
    "# # #city_water_gdf.plot(ax=ax, color='orange')\n",
    "# # print(city_water_gdf.loc[city_water_gdf.to_crs(equal_area_proj).geometry.area.apply(lambda x: x / (1000*1000)).sort_values(ascending=False).index.tolist()])\n",
    "# # city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'hbr' in str(x).lower())].plot(ax=ax, color='cyan')                \n",
    "# # city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'patapsco' in str(x).lower())].plot(ax=ax, color='cyan')\n",
    "# # city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'curtis' in str(x).lower())].plot(ax=ax, color='cyan')\n",
    "# # city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'colgate' in str(x).lower())].plot(ax=ax, color='cyan')\n",
    "# # city_water_gdf[city_water_gdf['HYDROID'] == '110190589339'].plot(ax=ax, color='cyan')   # Inner Harbor\n",
    "# # city_water_gdf[city_water_gdf['HYDROID'].isin(['110190589337','110190589300'])].plot(ax=ax, color='cyan')   # Two other spots in the harbor\n",
    "# # # for ix, thisrow in city_water_gdf.iterrows():\n",
    "# # #     ax.annotate(thisrow['HYDROID'], \n",
    "# # #                  xy=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "# # #                  xytext=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y),\n",
    "# # #                 backgroundcolor='white'\n",
    "# # #                 )\n",
    "\n",
    "\n",
    "\n",
    "# # city_water_gdf.loc[\n",
    "# #     city_water_gdf.to_crs(equal_area_proj).geometry.area.apply(lambda x: x / (1000*1000)).sort_values(ascending=False).head(5).index.tolist()\n",
    "# # ].plot(ax=ax, color='cyan')\n",
    "\n",
    "# #city_water_gdf[city_water_gdf['FULLNAME'].apply(lambda x: 'hbr' in str(x).lower())].plot(ax=ax, color='cyan')\n",
    "city_water_gdf.plot(ax=ax, color='cyan')\n",
    "\n",
    "# plt.xlim([430000,442000])\n",
    "# plt.ylim([170000,180000])\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "#print('ok')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "\n",
    "data_gdf['amtWorkingLoans_per_sbjob_adj'].hist()\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "thecolormap = 'Greys'\n",
    "print('making basic map...')\n",
    "\n",
    "fig1, ax = plt.subplots(1,1, figsize=(48*scale, 48*scale))\n",
    "\n",
    "# if (city == 'Pittsburgh'):\n",
    "#     city_boundary_parts_gdf[city_boundary_parts_gdf['thetype'] == 'enclave'].plot(ax=ax, color='white', hatch=not_in_city_hatch, edgecolor='black')\n",
    "\n",
    "# if (city == 'Baltimore'):\n",
    "#     baltimore_shapefiles_gdf.plot(ax=ax, color='white', hatch=no_data_hatch, edgecolor='black')\n",
    "# else:\n",
    "\n",
    "print('adding legend to label hatched area(s)...')\n",
    "\n",
    "no_data_legendizer = mpatches.Patch(facecolor='white', edgecolor='black', hatch=no_data_hatch, label='Fewer than {0:.0f} small business jobs and/or {1:.0f} people'.format(sb_jobs_lower_limit, pop_lower_limit))\n",
    "legendizer_list = [no_data_legendizer]\n",
    "\n",
    "if (show_water):\n",
    "    water_legendizer = mpatches.Patch(facecolor='white', edgecolor='black', hatch=water_hatch, label='Water area')\n",
    "    legendizer_list.append(water_legendizer)\n",
    "# if (city == 'Pittsburgh'):\n",
    "#     not_in_city_legendizer = mpatches.Patch(facecolor='white', edgecolor='black', hatch=not_in_city_hatch, label='Not part of city')\n",
    "#     legendizer_list.append(not_in_city_legendizer)\n",
    "    \n",
    "#if (len(legendizer_list) == 3):\n",
    "if ((city == 'Detroit') | (city == 'Cleveland') | (city == 'Philadelphia')):\n",
    "    plt.legend(handles=legendizer_list, fontsize=52*scale, loc='lower right')\n",
    "else:\n",
    "    plt.legend(handles=legendizer_list, fontsize=52*scale, loc='lower left')\n",
    "# else:\n",
    "#     plt.legend(handles=legendizer_list, fontsize=52*scale, loc='upper left')\n",
    "\n",
    "data_gdf.plot(ax=ax, color='white', hatch=no_data_hatch, edgecolor='black')\n",
    "\n",
    "\n",
    "\n",
    "data_gdf.plot(ax=ax, column='amtWorkingLoans_per_sbjob_adj', \n",
    "                         cmap=thecolormap, edgecolor='black', linewidth=2*scale)\n",
    "\n",
    "print('setting options...')\n",
    "ax.tick_params(axis='both', which='both', bottom=False, top=False, left=False, right=False, labelbottom=False, labelleft=False)\n",
    "plt.title('{0:} census tracts (n = {1:,.0f})'.format(city, len(data_gdf)), fontsize=64*scale, y=1.04)\n",
    "\n",
    "\n",
    "if (show_water):\n",
    "    print('adding water layer...')\n",
    "    city_water_gdf.plot(ax=ax, color='white', hatch=water_hatch, linewidth=2*scale)\n",
    "\n",
    "print('adding colorbar...')\n",
    "\n",
    "cax = fig1.add_axes([0.125, 0.08, 0.775, 0.03])\n",
    "\n",
    "sm = plt.cm.ScalarMappable(cmap=thecolormap, norm=plt.Normalize(\n",
    "    vmin=0, vmax=top_of_color_scale\n",
    "    #vmax=tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'].max()\n",
    "))\n",
    "## fake up the array of the scalar mappable. Urgh...\n",
    "sm._A = []\n",
    "\n",
    "if (color_scale_unit == 'million'):\n",
    "    rescalor = 1000000\n",
    "elif (color_scale_unit == 'thousand'):\n",
    "    rescalor = 1000\n",
    "else:\n",
    "    rescalor = np.nan\n",
    "\n",
    "cbar = fig1.colorbar(sm, cax=cax, orientation='horizontal',\n",
    "                     ticks=np.arange(0,top_of_color_scale+color_scale_tick_interval,color_scale_tick_interval)\n",
    "                    )\n",
    "\n",
    "\n",
    "\n",
    "cax.set_xticklabels(['${0:.1f}'.format(x/rescalor) for x in np.arange(0,top_of_color_scale+color_scale_tick_interval,color_scale_tick_interval)], fontsize=56*scale)\n",
    "\n",
    "cbar.set_label('Total working loans per small business job ({0:} {1:.0f}USD)'.format(color_scale_unit, latest_year), fontsize=68*scale)\n",
    "\n",
    "\n",
    "if (show_tract_labels):\n",
    "    print('showing tract labels...')\n",
    "    for ix, thisrow in tracts_included_gdf.iterrows():\n",
    "        #if (ix[1] in [1803.0, 1003.0, 2603.02, 2005.0, 2008.0, 2803.02, 2709.03, 1502.0, 401.0, 1902.0, 904.0, 2802.0, 1607.0, 2102.0, 2711.01, 1602.0, 902.0, 1703.0]):#, 1510.0, 801.02, 2602.02, 1308.03, 903.0, 1903.0, 1601.0, 1308.05, 2715.03, 2715.01, 1402.0, 105.0, 2701.01, 1605.0, 2007.02, 1506.0, 2706.0, 1201.0, 1206.0, 2709.01, 2709.02, 2718.01, 804.0, 1501.0, 1308.04, 1604.0, 2602.01, 2710.01, 1202.02, 1513.0, 2602.03, 2708.02, 1303.0, 2604.02, 2404.0, 2007.01, 1603.0]):\n",
    "        annotator = ''\n",
    "        annotator += str(ix[1])\n",
    "        annotator += '\\n'\n",
    "        annotator += '${0:,.0f}k'.format(thisrow['amtWorkingLoans_per_sbjob_adj']/1000)\n",
    "        ax.annotate(annotator, \n",
    "                    xy=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "                    xytext=(thisrow.geometry.centroid.x, thisrow.geometry.centroid.y), \n",
    "                    #backgroundcolor = 'white',\n",
    "                    horizontalalignment='center',\n",
    "                    verticalalignment='center',\n",
    "                    fontsize=24*scale,\n",
    "                    bbox=dict(facecolor='white', edgecolor='black', boxstyle='round')\n",
    "        )\n",
    "    map_outfile_name = figdir+'{0:}_map_labeled.jpg'.format(city.replace('.','').replace(' ','_').lower())\n",
    "else:\n",
    "    map_outfile_name = figdir+'{0:}_map_unlabeled.jpg'.format(city.replace('.','').replace(' ','_').lower())\n",
    "\n",
    "#plt.savefig(map_outfile_name, format='jpg', dpi=300*scale)\n",
    "plt.show()\n",
    "\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "\n",
    "print('Created map in {0:,.0f} seconds!'.format(e-s))\n",
    "#city_water_gdf.head(1).T#[city_water_gdf['FULLNAME'] == 'Harbor']\n",
    "\n",
    "print(tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'].max())\n",
    "np.ceil(tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'].max()/rescalor)*rescalor\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "\n",
    "# print('getting from backup...')\n",
    "# tracts_included_gdf = tracts_included_gdf_bk\n",
    "\n",
    "# print('identifying tracts by poverty rate...')\n",
    "# tracts_included_gdf = tracts_included_gdf.assign(poverty_class_2019 = np.nan)\n",
    "# tracts_included_gdf.loc[tracts_included_gdf['pct_poverty_2019'] > 0.3, 'poverty_class_2019'] = 'much'\n",
    "# tracts_included_gdf.loc[tracts_included_gdf['pct_poverty_2019'] < 0.1, 'poverty_class_2019'] = 'little'\n",
    "\n",
    "# print('identifying tracts with higher-than-average percentages of white and black people...')\n",
    "# city_pct_white = tracts_included_gdf['pop_white_2019'].sum() / tracts_included_gdf['pop_total_2019'].sum()\n",
    "# city_pct_black = tracts_included_gdf['pop_black_2019'].sum() / tracts_included_gdf['pop_total_2019'].sum()\n",
    "\n",
    "# tracts_included_gdf = tracts_included_gdf.assign(excess_race_2019 = np.nan)\n",
    "# tracts_included_gdf.loc[tracts_included_gdf['pct_white_2019'] > city_pct_white, 'excess_race_2019'] = 'white'\n",
    "# tracts_included_gdf.loc[tracts_included_gdf['pct_black_2019'] > city_pct_black, 'excess_race_2019'] = 'black'\n",
    "# tracts_included_gdf.loc[:, 'excess_race_2019'] = tracts_included_gdf['excess_race_2019'].fillna('other')\n",
    "\n",
    "# print('backing up...')\n",
    "# tracts_included_gdf_bk = tracts_included_gdf\n",
    "\n",
    "print('identifying tracts by poverty rate...')\n",
    "tracts_included_gdf = tracts_included_gdf.assign(poverty_class_2017 = np.nan)\n",
    "tracts_included_gdf.loc[tracts_included_gdf['pct_poverty_2017'] > 0.3, 'poverty_class_2017'] = 'much'\n",
    "tracts_included_gdf.loc[tracts_included_gdf['pct_poverty_2017'] < 0.1, 'poverty_class_2017'] = 'little'\n",
    "\n",
    "print('identifying tracts with higher-than-average percentages of white and black people...')\n",
    "city_pct_white = tracts_included_gdf['pop_white_2017'].sum() / tracts_included_gdf['pop_total_2017'].sum()\n",
    "city_pct_black = tracts_included_gdf['pop_black_2017'].sum() / tracts_included_gdf['pop_total_2017'].sum()\n",
    "\n",
    "tracts_included_gdf = tracts_included_gdf.assign(excess_race_2017 = np.nan)\n",
    "tracts_included_gdf.loc[tracts_included_gdf['pct_white_2017'] > city_pct_white, 'excess_race_2017'] = 'white'\n",
    "tracts_included_gdf.loc[tracts_included_gdf['pct_black_2017'] > city_pct_black, 'excess_race_2017'] = 'black'\n",
    "tracts_included_gdf.loc[:, 'excess_race_2017'] = tracts_included_gdf['excess_race_2017'].fillna('other')\n",
    "\n",
    "\n",
    "tracts_included_gdf.sample(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Divide tracts into categories by..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## poverty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "\n",
    "summary['city_pct_black'] = city_pct_black\n",
    "\n",
    "cra_level_poverty_df = pandas.DataFrame()\n",
    "# cra_level_poverty_df = cra_level_poverty_df.assign(nTracts = tracts_included_gdf[tracts_included_gdf['cra_level_2019'] != 'unknown'].groupby(['poverty_class_2019','cra_level_2019']).size())\n",
    "# cra_level_poverty_df = cra_level_poverty_df.assign(mean_amtWorkingLoans_per_sbjob_adj = tracts_included_gdf[tracts_included_gdf['cra_level_2019'] != 'unknown'].groupby(['poverty_class_2019','cra_level_2019'])['amtWorkingLoans_per_sbjob_adj'].mean())\n",
    "# cra_level_poverty_df = cra_level_poverty_df.assign(sem_amtWorkingLoans_per_sbjob_adj = tracts_included_gdf[tracts_included_gdf['cra_level_2019'] != 'unknown'].groupby(['poverty_class_2019','cra_level_2019'])['amtWorkingLoans_per_sbjob_adj'].sem())\n",
    "cra_level_poverty_df = cra_level_poverty_df.assign(nTracts = tracts_included_gdf[tracts_included_gdf['cra_level_2017'] != 'unknown'].groupby(['poverty_class_2017','cra_level_2017']).size())\n",
    "cra_level_poverty_df = cra_level_poverty_df.assign(mean_amtWorkingLoans_per_sbjob_adj = tracts_included_gdf[tracts_included_gdf['cra_level_2017'] != 'unknown'].groupby(['poverty_class_2017','cra_level_2017'])['amtWorkingLoans_per_sbjob_adj'].mean())\n",
    "cra_level_poverty_df = cra_level_poverty_df.assign(sem_amtWorkingLoans_per_sbjob_adj = tracts_included_gdf[tracts_included_gdf['cra_level_2017'] != 'unknown'].groupby(['poverty_class_2017','cra_level_2017'])['amtWorkingLoans_per_sbjob_adj'].sem())\n",
    "\n",
    "# If any values of cra_level_poverty_df are missing, fill them with nan's\n",
    "for x in ['little', 'much']:\n",
    "    for y in ['low', 'moderate', 'middle', 'upper']:\n",
    "        try:\n",
    "            if (cra_level_poverty_df.loc[(x,y)]['nTracts'] > 0):\n",
    "                pass\n",
    "            else:\n",
    "                print('else',x,y)\n",
    "        except:\n",
    "            cra_level_poverty_df.loc[(x,y), ['nTracts', 'mean_amtWorkingLoans_per_sbjob_adj', 'sem_amtWorkingLoans_per_sbjob_adj']] = [0, np.nan, np.nan]\n",
    "    \n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "\n",
    "print('Done in {0:,.2f} seconds!'.format(e-s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## race"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "\n",
    "# #excess_race_2019_list = tracts_included_gdf['excess_race_2019'].drop_duplicates().tolist()\n",
    "# #cra_level_list = tracts_included_gdf['cra_level_2019'].drop_duplicates().tolist()\n",
    "\n",
    "# excess_race_2019_list = ['white', 'black', 'other']\n",
    "# cra_level_list = ['low', 'moderate', 'middle', 'upper', 'unknown']\n",
    "excess_race_2017_list = ['white', 'black', 'other']\n",
    "cra_level_list = ['low', 'moderate', 'middle', 'upper', 'unknown']\n",
    "#\n",
    "\n",
    "cra_level_race_df = pandas.DataFrame(data=None, columns=['nTracts', 'mean_amtWorkingLoans_per_sbjob_adj', 'sem_amtWorkingLoans_per_sbjob_adj'], index=pandas.MultiIndex.from_product([excess_race_2017_list,cra_level_list]))\n",
    "\n",
    "# for this_race in excess_race_2019_list:\n",
    "#     for this_level in cra_level_list:\n",
    "#         cra_level_race_df.loc[(this_race, this_level), 'nTracts'] = tracts_included_gdf[\n",
    "#             (tracts_included_gdf['excess_race_2019'] == this_race)\n",
    "#             & (tracts_included_gdf['cra_level_2019'] == this_level)\n",
    "#         ].count().values[0]\n",
    "        \n",
    "#         cra_level_race_df.loc[(this_race, this_level), 'mean_amtWorkingLoans_per_sbjob_adj'] = tracts_included_gdf[\n",
    "#             (tracts_included_gdf['excess_race_2019'] == this_race)\n",
    "#             & (tracts_included_gdf['cra_level_2019'] == this_level)\n",
    "#         ]['amtWorkingLoans_per_sbjob_adj'].mean()\n",
    "\n",
    "#         cra_level_race_df.loc[(this_race, this_level), 'sem_amtWorkingLoans_per_sbjob_adj'] = tracts_included_gdf[\n",
    "#             (tracts_included_gdf['excess_race_2019'] == this_race)\n",
    "#             & (tracts_included_gdf['cra_level_2019'] == this_level)\n",
    "#         ]['amtWorkingLoans_per_sbjob_adj'].sem()\n",
    "\n",
    "for this_race in excess_race_2017_list:\n",
    "    for this_level in cra_level_list:\n",
    "        cra_level_race_df.loc[(this_race, this_level), 'nTracts'] = tracts_included_gdf[\n",
    "            (tracts_included_gdf['excess_race_2017'] == this_race)\n",
    "            & (tracts_included_gdf['cra_level_2017'] == this_level)\n",
    "        ].count().values[0]\n",
    "        \n",
    "        cra_level_race_df.loc[(this_race, this_level), 'mean_amtWorkingLoans_per_sbjob_adj'] = tracts_included_gdf[\n",
    "            (tracts_included_gdf['excess_race_2017'] == this_race)\n",
    "            & (tracts_included_gdf['cra_level_2017'] == this_level)\n",
    "        ]['amtWorkingLoans_per_sbjob_adj'].mean()\n",
    "\n",
    "        cra_level_race_df.loc[(this_race, this_level), 'sem_amtWorkingLoans_per_sbjob_adj'] = tracts_included_gdf[\n",
    "            (tracts_included_gdf['excess_race_2017'] == this_race)\n",
    "            & (tracts_included_gdf['cra_level_2017'] == this_level)\n",
    "        ]['amtWorkingLoans_per_sbjob_adj'].sem()\n",
    "\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "print('Done in {0:.1f} seconds!'.format(e-s))\n",
    "#cra_level_race_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "bar_chart_df = pandas.DataFrame(data=None, columns=['mean_amtWorkingLoans_adj_per_sbjob'])\n",
    "# bar_chart_df.loc[\n",
    "#     'little poverty / much poverty', 'mean_amtWorkingLoans_adj_per_sbjob'\n",
    "# ] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "#     (tracts_included_gdf['poverty_class_2019'] == 'little') & (tracts_included_gdf['cra_level_2019'] != 'unknown')\n",
    "# ].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "#     (tracts_included_gdf['poverty_class_2019'] == 'much') & (tracts_included_gdf['cra_level_2019'] != 'unknown')\n",
    "# ].mean()\n",
    "\n",
    "bar_chart_df.loc[\n",
    "    'little poverty / much poverty', 'mean_amtWorkingLoans_adj_per_sbjob'\n",
    "] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "    (tracts_included_gdf['poverty_class_2017'] == 'little') & (tracts_included_gdf['cra_level_2017'] != 'unknown')\n",
    "].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "    (tracts_included_gdf['poverty_class_2017'] == 'much') & (tracts_included_gdf['cra_level_2017'] != 'unknown')\n",
    "].mean()\n",
    "\n",
    "# bar_chart_df.loc[\n",
    "#     'excess white / excess black', 'mean_amtWorkingLoans_adj_per_sbjob'\n",
    "# ] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "#     (tracts_included_gdf['excess_race_2019'] == 'white') & (tracts_included_gdf['cra_level_2019'] != 'unknown')\n",
    "# ].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "#     (tracts_included_gdf['excess_race_2019'] == 'black') & (tracts_included_gdf['cra_level_2019'] != 'unknown')\n",
    "# ].mean()\n",
    "#bar_chart_df.loc['excess white / excess black', 'mean_amtWorkingLoans_adj_per_sbjob'] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2019'] == 'white'].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2019'] == 'black'].mean()\n",
    "\n",
    "bar_chart_df.loc[\n",
    "    'excess white / excess black', 'mean_amtWorkingLoans_adj_per_sbjob'\n",
    "] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "    (tracts_included_gdf['excess_race_2017'] == 'white') & (tracts_included_gdf['cra_level_2017'] != 'unknown')\n",
    "].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][\n",
    "    (tracts_included_gdf['excess_race_2017'] == 'black') & (tracts_included_gdf['cra_level_2017'] != 'unknown')\n",
    "].mean()\n",
    "#bar_chart_df.loc['excess white / excess black', 'mean_amtWorkingLoans_adj_per_sbjob'] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2019'] == 'white'].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2019'] == 'black'].mean()\n",
    "\n",
    "fig2, ax = plt.subplots(1,1, figsize=(36*scale, 24*scale))\n",
    "bar_chart_df.plot.bar(ax=ax, color='black')\n",
    "\n",
    "plt.xticks(np.arange(0,2), bar_chart_df.index.values, rotation='horizontal', fontsize=48*scale)\n",
    "\n",
    "plt.ylabel('Ratio of mean lending per tract', fontsize=56*scale)\n",
    "plt.yticks(np.arange(0, 2, 0.25), np.arange(0, 2, 0.25), fontsize=48*scale)\n",
    "\n",
    "plt.title('{0:}: Ratios of per-tract lending by poverty and race'.format(city), fontsize=56*scale, y=1.02)\n",
    "ax.get_legend().remove()\n",
    "\n",
    "plt.savefig(figdir+'{0:}_lending_ratios.jpg'.format(city.lower().replace('.','').replace(' ','_')), format='jpg', dpi=300*scale)\n",
    "\n",
    "#summary['lending_ratio_race'] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2019'] == 'white'].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2019'] == 'black'].mean()\n",
    "summary['lending_ratio_race'] = tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2017'] == 'white'].mean() / tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['excess_race_2017'] == 'black'].mean()\n",
    "\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "print('Done in {0:.2f} seconds!'.format(e-s))\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "\n",
    "fig3, ax = plt.subplots(1,1, figsize=(36*scale, 24*scale))\n",
    "\n",
    "\n",
    "label_sorter = np.arange(5).tolist()\n",
    "width = 0.35\n",
    "print(label_sorter)\n",
    "\n",
    "white_means = cra_level_race_df.xs('white')['mean_amtWorkingLoans_per_sbjob_adj'].tolist()\n",
    "black_means = cra_level_race_df.xs('black')['mean_amtWorkingLoans_per_sbjob_adj'].tolist()\n",
    "other_means = cra_level_race_df.xs('other')['mean_amtWorkingLoans_per_sbjob_adj'].tolist()\n",
    "\n",
    "white_sems = cra_level_race_df.xs('white')['sem_amtWorkingLoans_per_sbjob_adj'].tolist()\n",
    "black_sems = cra_level_race_df.xs('black')['sem_amtWorkingLoans_per_sbjob_adj'].tolist()\n",
    "other_sems = cra_level_race_df.xs('other')['sem_amtWorkingLoans_per_sbjob_adj'].tolist()\n",
    "\n",
    "for thisvar in [white_means, white_sems, black_means, black_sems]:\n",
    "    for i in range(0, len(label_sorter)):\n",
    "        if (np.isnan(thisvar[i])):\n",
    "            thisvar[i] = 0\n",
    "            \n",
    "for i in label_sorter:\n",
    "    print('White {0}: mean = ${1:,.0f}, sem = ${2:,.0f}'.format(label_sorter[i], white_means[i], white_sems[i]))\n",
    "    print('Black {0}: mean = ${1:,.0f}, sem = ${2:,.0f}'.format(label_sorter[i], black_means[i], black_sems[i]))\n",
    "\n",
    "plt.bar(label_sorter[:-1], white_means[:-1], width, yerr=white_sems[:-1], label='White', color='lightgray', error_kw=dict(lw=5*scale, capsize=18*scale, capthick=5*scale))\n",
    "plt.bar([x+width for x in label_sorter[:-1]], black_means[:-1], width, yerr=black_sems[:-1], label='Black', color='darkgray', error_kw=dict(lw=5*scale, capsize=18*scale, capthick=5*scale))\n",
    "\n",
    "\n",
    "plt.xticks([x+(width/2) for x in label_sorter[:-1]], ['low', 'middle', 'moderate', 'upper'], fontsize=48*scale)\n",
    "plt.yticks(fontsize=48*scale)\n",
    "\n",
    "\n",
    "ticks_loc = ax.get_yticks().tolist()\n",
    "ax.set_yticks(ax.get_yticks().tolist())\n",
    "\n",
    "tick_label_list = []\n",
    "for tick in ax.get_yticks():\n",
    "    tick_label_list.append(tick)\n",
    "tick_label_list = ['${0:.0f}'.format(x/1000) for x in tick_label_list]\n",
    "\n",
    "ax.set_yticklabels(tick_label_list)\n",
    "\n",
    "plt.xlabel('CRA income level', fontsize=54*scale)\n",
    "plt.ylabel('Mean loan amount upper SB job\\n(thousands)', fontsize=64*scale)\n",
    "plt.title('{0:}: Loans per job by CRA level and race'.format(city), fontsize=56*scale, y=1.02)\n",
    "\n",
    "plt.savefig(figdir+'{0:}_cra_level_race.jpg'.format(city.lower().replace('.','').replace(' ','_')), format='jpg', dpi=300*scale)\n",
    "\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "print('Done in {0:.2f} seconds!'.format(e-s))\n",
    "\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "# slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(\n",
    "#     tracts_included_gdf['pct_black_2019'][tracts_included_gdf['pct_black_2019'].notnull()].apply(lambda x: x * 100).values, \n",
    "#     tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['pct_black_2019'].notnull()].values\n",
    "# )\n",
    "slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(\n",
    "    tracts_included_gdf['pct_black_2017'][tracts_included_gdf['pct_black_2017'].notnull()].apply(lambda x: x * 100).values, \n",
    "    tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'][tracts_included_gdf['pct_black_2017'].notnull()].values\n",
    ")\n",
    "\n",
    "summary['race_fit_slope'] = slope\n",
    "summary['race_fit_rsq'] = r_value**2\n",
    "\n",
    "fig3, (ax3) = plt.subplots(1,1, figsize=(36*scale,18*scale))\n",
    "#siz = tracts_included_gdf['sb_jobs_2018'].apply(lambda x: (0.05*x)*(scale**2)).tolist()\n",
    "siz = tracts_included_gdf['sb_jobs_2017'].apply(lambda x: (0.05*x)*(scale**2)).tolist()\n",
    "\n",
    "#mfi_colormap = cm.viridis(np.linspace(0, 1, len(tracts_included_gdf)))\n",
    "\n",
    "# ax3.scatter(tracts_included_gdf['pct_black_2019'], \n",
    "#             tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'], \n",
    "#             s=siz, c=tracts_included_gdf['mfi_adj_2019'], cmap=thecolormap)\n",
    "ax3.scatter(tracts_included_gdf['pct_black_2017'], \n",
    "            tracts_included_gdf['amtWorkingLoans_per_sbjob_adj'], \n",
    "            s=siz, c=tracts_included_gdf['mfi_adj_2017'], cmap=thecolormap)\n",
    "\n",
    "# ax3.plot(tracts_included_gdf['pct_black_2019'], slope*tracts_included_gdf['pct_black_2019'].apply(lambda x: x * 100) + intercept, \n",
    "#          color='black', linewidth=8*scale)\n",
    "ax3.plot(tracts_included_gdf['pct_black_2017'], slope*tracts_included_gdf['pct_black_2017'].apply(lambda x: x * 100) + intercept, \n",
    "         color='black', linewidth=8*scale)\n",
    "\n",
    "ax3.set_xlabel('Percent black residents', fontsize=64*scale)\n",
    "ax3.set_ylabel('Total working loans per small\\nbusiness job (thousands)', fontsize=44*scale)\n",
    "\n",
    "\n",
    "xticks = np.arange(0, 1.2, 0.2)\n",
    "\n",
    "xlabels = ['{0:.0%}'.format(x) for x in xticks]\n",
    "plt.xticks(xticks, xlabels, fontsize=48*scale)\n",
    "\n",
    "tick_label_list = []\n",
    "for tick in ax3.get_yticks():\n",
    "    tick_label_list.append(tick)\n",
    "\n",
    "tick_label_list = ['${0:.0f}'.format(x/1000) for x in tick_label_list]\n",
    "ax3.set_yticklabels(tick_label_list, fontsize=36*scale)\n",
    "\n",
    "plt.title('{0:}: Linear model of Loans per job by race'.format(city), fontsize=54*scale, y=1.02)\n",
    "\n",
    "\n",
    "print('adding colorbar...')\n",
    "\n",
    "# sm = plt.cm.ScalarMappable(cmap=thecolormap, norm=plt.Normalize(\n",
    "#     vmin=tracts_included_gdf['mfi_adj_2019'].min(), \n",
    "#     vmax=tracts_included_gdf['mfi_adj_2019'].max()\n",
    "# ))\n",
    "sm = plt.cm.ScalarMappable(cmap=thecolormap, norm=plt.Normalize(\n",
    "    vmin=tracts_included_gdf['mfi_adj_2017'].min(), \n",
    "    vmax=tracts_included_gdf['mfi_adj_2017'].max()\n",
    "))\n",
    "## fake up the array of the scalar mappable. Urgh...\n",
    "sm._A = []\n",
    "\n",
    "\n",
    "#cax = fig3.add_axes()#[0.85, 0.4, .95, 0.5])\n",
    "\n",
    "cbar = fig3.colorbar(sm)\n",
    "\n",
    "cbarticklabels = []\n",
    "for t in cbar.ax.get_yticks(): \n",
    "    cbarticklabels.append(t)\n",
    "    #t = int(t.get_text()) / 1000#print(t.get_text())\n",
    "cbarticklabels = ['${0:.0f}'.format(x/1000) for x in cbarticklabels]\n",
    "cbar.set_ticks([x for x in cbar.ax.get_yticks()])\n",
    "cbar.set_ticklabels(cbarticklabels)\n",
    "cbar.ax.tick_params(labelsize=28*scale) \n",
    "cbar.set_label('Median family income (thousands)', rotation=90, size=36*scale, labelpad=25)#, y=1.05, rotation=90)\n",
    "\n",
    "plt.savefig(figdir+'{0:}_linear_fit_race.jpg'.format(city.lower().replace('.','').replace(' ','_')), format='jpg', dpi=300*scale)\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "print('Done in {0:.2f} seconds!'.format(e-s))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = time.time()\n",
    "\n",
    "# summary['pop_all_tracts_2019'] = all_tracts_gdf['pop_total_2019'].sum()\n",
    "# summary['pop_included_in_study_2019'] = tracts_included_gdf['pop_total_2019'].sum()\n",
    "# summary['sb_jobs_included_in_study_2018'] = tracts_included_gdf['sb_jobs_2018'].sum()\n",
    "summary['pop_all_tracts_2017'] = all_tracts_gdf['pop_total_2017'].sum()\n",
    "summary['pop_included_in_study_2017'] = tracts_included_gdf['pop_total_2017'].sum()\n",
    "summary['sb_jobs_included_in_study_2017'] = tracts_included_gdf['sb_jobs_2017'].sum()\n",
    "\n",
    "summary['tracts_included'] = tracts_included_gdf.shape[0]\n",
    "summary['nWorkingLoans'] = tracts_included_gdf['nWorkingLoans'].sum()\n",
    "summary['amtWorkingLoans_adj'] = tracts_included_gdf['amtWorkingLoans_adj'].sum()\n",
    "\n",
    "if (summary['race_fit_slope'] >= 0):\n",
    "    summary['slopesign'] = ''\n",
    "else:\n",
    "    summary['slopesign'] = '-'\n",
    "    \n",
    "# text = '{0:}'.format(city.upper())\n",
    "# text += '\\n'\n",
    "# text += 'Total city population: {0:,.0f}\\n'.format(summary['pop_all_tracts_2019'])\n",
    "# text += 'Population included in study: {0:,.0f}\\n'.format(summary['pop_included_in_study_2019'])\n",
    "# text += 'Small business jobs included in study: {0:,.0f}\\n'.format(summary['sb_jobs_included_in_study_2018'])\n",
    "# text += '\\n'\n",
    "# text += 'Census tracts included in study: {0:,.0f}\\n'.format(summary['tracts_included'])\n",
    "# text += 'City-wide percent black residents: {0:.1%}\\n'.format(summary['city_pct_black'])\n",
    "# text += 'Number of working loans: {0:,.0f}\\n'.format(summary['nWorkingLoans'])\n",
    "# text += 'Total amount of working loans ({0:.0f}USD): ${1:,.0f}\\n'.format(latest_year,summary['amtWorkingLoans_adj'])\n",
    "# text += '\\n'\n",
    "# text += 'Race lending ratio: {0:.2f}\\n'.format(summary['lending_ratio_race'])\n",
    "# text += 'Slope of best-fit line for lending by race:\\n\\t{0:}${1:,.0f} per SB job per percent black (r^2 = {2:.3f})'.format(summary['slopesign'], np.abs(summary['race_fit_slope']), summary['race_fit_rsq'])\n",
    "\n",
    "text = '{0:}'.format(city.upper())\n",
    "text += '\\n'\n",
    "text += 'Total city population: {0:,.0f}\\n'.format(summary['pop_all_tracts_2017'])\n",
    "text += 'Population included in study: {0:,.0f}\\n'.format(summary['pop_included_in_study_2017'])\n",
    "text += 'Small business jobs included in study: {0:,.0f}\\n'.format(summary['sb_jobs_included_in_study_2017'])\n",
    "text += '\\n'\n",
    "text += 'Census tracts included in study: {0:,.0f}\\n'.format(summary['tracts_included'])\n",
    "text += 'City-wide percent black residents: {0:.1%}\\n'.format(summary['city_pct_black'])\n",
    "text += 'Number of working loans: {0:,.0f}\\n'.format(summary['nWorkingLoans'])\n",
    "text += 'Total amount of working loans ({0:.0f}USD): ${1:,.0f}\\n'.format(latest_year,summary['amtWorkingLoans_adj'])\n",
    "text += '\\n'\n",
    "text += 'Race lending ratio: {0:.2f}\\n'.format(summary['lending_ratio_race'])\n",
    "text += 'Slope of best-fit line for lending by race:\\n\\t{0:}${1:,.0f} per SB job per percent black (r^2 = {2:.3f})'.format(summary['slopesign'], np.abs(summary['race_fit_slope']), summary['race_fit_rsq'])\n",
    "\n",
    "print('writing summary file...')\n",
    "with io.open(figdir+'{0:}_summary.txt'.format(city.lower().replace('.','').replace(' ','_')), 'w') as f:\n",
    "    f.write(text)\n",
    "\n",
    "e = time.time()\n",
    "g = g + (e-s)\n",
    "print('\\n')\n",
    "print('Grand total time: {0:.1f} seconds!'.format(g))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8 (py38)",
   "language": "python",
   "name": "py38"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}