diff --git a/gridle_python/notebooks/gridle-init.ipynb b/gridle_python/notebooks/gridle-init.ipynb index 6cb67e3..77b2a86 100644 --- a/gridle_python/notebooks/gridle-init.ipynb +++ b/gridle_python/notebooks/gridle-init.ipynb @@ -10,52 +10,99 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "ecea6591-1381-4565-9608-260f385bb506", "metadata": {}, "outputs": [], "source": [ + "import os\n", + "import pathlib\n", + "\n", + "import chart_studio\n", "import chart_studio.plotly as py\n", + "import pandas as pd\n", "import plotly.graph_objects as go\n", - "import plotly" + "import plotly\n", + "import sqlalchemy as sa" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "71fd409f-a08e-4fee-8952-ca5911d5d05e", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: NO CHART STUDIO LOGIN INFO FOUND\n" + ] + } + ], + "source": [ + "try:\n", + " username = os.environ[\"CHART_STUDIO_USERNAME\"]\n", + " api_key = os.environ[\"CHART_STUDIO_KEY\"]\n", + " chart_studio.tools.set_credentials_file(username=username, api_key=api_key)\n", + "except KeyError:\n", + " print(\"WARNING: NO CHART STUDIO LOGIN INFO FOUND\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e02b5c1b", + "metadata": {}, "outputs": [], "source": [ - "import chart_studio\n", - "import os\n", - "\n", - "\n", - "username = os.environ[\"CHART_STUDIO_USERNAME\"]\n", - "api_key = os.environ[\"CHART_STUDIO_KEY\"]\n", - "chart_studio.tools.set_credentials_file(username=username, api_key=api_key)" + "def get_gridle_path() -> pathlib.Path:\n", + " \"\"\"Returns path to the gridle repo. \n", + " \n", + " Note: this will work only if jupyter is launched from somewhere within the repo.\n", + " \"\"\"\n", + " path = pathlib.Path.cwd()\n", + " while path.name != \"/\":\n", + " if path.name == \"gridle\":\n", + " return path\n", + " \n", + " path = path.parent\n", + " \n", + " raise ValueError(\n", + " \"Couldn't find gridle repo path. \"\n", + " \"You are probably running jupyter from outside of gridle repo.\"\n", + " )" ] }, { "cell_type": "code", "execution_count": 4, - "id": "31e1ecb4-43d6-4b0c-a495-ee2d0831ef2f", + "id": "777c50bc", "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading PUDL sqllite data from: sqlite:////Users/jakebass/git/gridle/pudl.sqlite\n" + ] + } + ], "source": [ - "import pandas as pd\n", - "import sqlalchemy as sa\n", + "# Download pudl.sqlite ~12 GB\n", + "# wget https://s3.us-west-2.amazonaws.com/pudl.catalyst.coop/dev/pudl.sqlite\n", "\n", - "# Download pudl.sqlite ~10 GB\n", - "# https://s3.us-west-2.amazonaws.com/pudl.catalyst.coop/dev/pudl.sqlite\n", - "\n", - "engine = sa.create_engine(\"sqlite:////Users/bendnorman/catalyst/dagster-pudl-work/pudl_output/full_eia_pudl.sqlite\")\n", + "# engine = sa.create_engine(\"sqlite:////Users/bendnorman/catalyst/dagster-pudl-work/pudl_output/full_eia_pudl.sqlite\")\n", + "sqllite_path = \"sqlite:///\" + str(get_gridle_path().joinpath(\"pudl.sqlite\"))\n", + "print(f\"Reading PUDL sqllite data from: {sqllite_path}\")\n", + "engine = sa.create_engine(sqllite_path)\n", "\n", "with engine.connect() as con:\n", " plants_entity_eia = pd.read_sql_table(\"plants_entity_eia\", con)\n", - " generation = pd.read_sql_table(\"denorm_generation_fuel_combined_yearly_eia923\", con)\n" + " generation = pd.read_sql_table(\"denorm_generation_fuel_combined_yearly_eia923\", con)\n", + " generation = generation.assign(report_year=lambda df: df.report_date.dt.year)\n" ] }, { @@ -71,22 +118,22 @@ "output_type": "stream", "text": [ "\n", - "RangeIndex: 16212 entries, 0 to 16211\n", + "RangeIndex: 16420 entries, 0 to 16419\n", "Data columns (total 10 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", - " 0 plant_id_eia 16212 non-null int64 \n", - " 1 plant_name_eia 15943 non-null object \n", - " 2 city 15130 non-null object \n", - " 3 county 15306 non-null object \n", - " 4 latitude 15221 non-null float64\n", - " 5 longitude 15412 non-null float64\n", - " 6 state 15938 non-null object \n", - " 7 street_address 14713 non-null object \n", - " 8 zip_code 15420 non-null object \n", - " 9 timezone 15943 non-null object \n", + " 0 plant_id_eia 16420 non-null int64 \n", + " 1 plant_name_eia 16151 non-null object \n", + " 2 city 15434 non-null object \n", + " 3 county 15502 non-null object \n", + " 4 latitude 15409 non-null float64\n", + " 5 longitude 15621 non-null float64\n", + " 6 state 16146 non-null object \n", + " 7 street_address 15032 non-null object \n", + " 8 zip_code 15731 non-null object \n", + " 9 timezone 16150 non-null object \n", "dtypes: float64(2), int64(1), object(7)\n", - "memory usage: 1.2+ MB\n" + "memory usage: 1.3+ MB\n" ] } ], @@ -107,28 +154,30 @@ "output_type": "stream", "text": [ "\n", - "RangeIndex: 244796 entries, 0 to 244795\n", - "Data columns (total 16 columns):\n", + "RangeIndex: 244795 entries, 0 to 244794\n", + "Data columns (total 18 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", - " 0 report_date 244796 non-null datetime64[ns]\n", - " 1 plant_id_eia 244796 non-null int64 \n", - " 2 plant_id_pudl 244796 non-null int64 \n", - " 3 plant_name_eia 244796 non-null object \n", - " 4 utility_id_eia 244796 non-null int64 \n", - " 5 utility_id_pudl 244796 non-null int64 \n", - " 6 utility_name_eia 244796 non-null object \n", - " 7 energy_source_code 244796 non-null object \n", - " 8 fuel_type_code_pudl 244796 non-null object \n", - " 9 prime_mover_code 244796 non-null object \n", - " 10 fuel_consumed_units 244796 non-null float64 \n", - " 11 fuel_consumed_for_electricity_units 244796 non-null float64 \n", - " 12 fuel_mmbtu_per_unit 204765 non-null float64 \n", - " 13 fuel_consumed_mmbtu 244796 non-null float64 \n", - " 14 fuel_consumed_for_electricity_mmbtu 244796 non-null float64 \n", - " 15 net_generation_mwh 244796 non-null float64 \n", - "dtypes: datetime64[ns](1), float64(6), int64(4), object(5)\n", - "memory usage: 29.9+ MB\n" + " 0 report_date 244795 non-null datetime64[ns]\n", + " 1 plant_id_eia 244795 non-null int64 \n", + " 2 plant_id_pudl 244795 non-null int64 \n", + " 3 plant_name_eia 244795 non-null object \n", + " 4 utility_id_eia 244795 non-null int64 \n", + " 5 utility_id_pudl 244795 non-null int64 \n", + " 6 utility_name_eia 244795 non-null object \n", + " 7 energy_source_code 244795 non-null object \n", + " 8 fuel_type_code_pudl 244795 non-null object \n", + " 9 prime_mover_code 244795 non-null object \n", + " 10 fuel_consumed_units 244795 non-null float64 \n", + " 11 fuel_consumed_for_electricity_units 244795 non-null float64 \n", + " 12 fuel_mmbtu_per_unit 204764 non-null float64 \n", + " 13 fuel_consumed_mmbtu 244795 non-null float64 \n", + " 14 fuel_consumed_for_electricity_mmbtu 244795 non-null float64 \n", + " 15 net_generation_mwh 244795 non-null float64 \n", + " 16 data_maturity 244795 non-null object \n", + " 17 report_year 244795 non-null int32 \n", + "dtypes: datetime64[ns](1), float64(6), int32(1), int64(4), object(6)\n", + "memory usage: 32.7+ MB\n" ] } ], @@ -161,37 +210,39 @@ "output_type": "stream", "text": [ "\n", - "RangeIndex: 244796 entries, 0 to 244795\n", - "Data columns (total 25 columns):\n", + "RangeIndex: 244795 entries, 0 to 244794\n", + "Data columns (total 27 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", - " 0 report_date 244796 non-null datetime64[ns]\n", - " 1 plant_id_eia 244796 non-null int64 \n", - " 2 plant_id_pudl 244796 non-null int64 \n", - " 3 plant_name_eia_x 244796 non-null object \n", - " 4 utility_id_eia 244796 non-null int64 \n", - " 5 utility_id_pudl 244796 non-null int64 \n", - " 6 utility_name_eia 244796 non-null object \n", - " 7 energy_source_code 244796 non-null object \n", - " 8 fuel_type_code_pudl 244796 non-null object \n", - " 9 prime_mover_code 244796 non-null object \n", - " 10 fuel_consumed_units 244796 non-null float64 \n", - " 11 fuel_consumed_for_electricity_units 244796 non-null float64 \n", - " 12 fuel_mmbtu_per_unit 204765 non-null float64 \n", - " 13 fuel_consumed_mmbtu 244796 non-null float64 \n", - " 14 fuel_consumed_for_electricity_mmbtu 244796 non-null float64 \n", - " 15 net_generation_mwh 244796 non-null float64 \n", - " 16 plant_name_eia_y 244796 non-null object \n", - " 17 city 238771 non-null object \n", - " 18 county 234120 non-null object \n", - " 19 latitude 241658 non-null float64 \n", - " 20 longitude 244381 non-null float64 \n", - " 21 state 244728 non-null object \n", - " 22 street_address 230306 non-null object \n", - " 23 zip_code 238122 non-null object \n", - " 24 timezone 244796 non-null object \n", - "dtypes: datetime64[ns](1), float64(8), int64(4), object(12)\n", - "memory usage: 46.7+ MB\n" + " 0 report_date 244795 non-null datetime64[ns]\n", + " 1 plant_id_eia 244795 non-null int64 \n", + " 2 plant_id_pudl 244795 non-null int64 \n", + " 3 plant_name_eia_x 244795 non-null object \n", + " 4 utility_id_eia 244795 non-null int64 \n", + " 5 utility_id_pudl 244795 non-null int64 \n", + " 6 utility_name_eia 244795 non-null object \n", + " 7 energy_source_code 244795 non-null object \n", + " 8 fuel_type_code_pudl 244795 non-null object \n", + " 9 prime_mover_code 244795 non-null object \n", + " 10 fuel_consumed_units 244795 non-null float64 \n", + " 11 fuel_consumed_for_electricity_units 244795 non-null float64 \n", + " 12 fuel_mmbtu_per_unit 204764 non-null float64 \n", + " 13 fuel_consumed_mmbtu 244795 non-null float64 \n", + " 14 fuel_consumed_for_electricity_mmbtu 244795 non-null float64 \n", + " 15 net_generation_mwh 244795 non-null float64 \n", + " 16 data_maturity 244795 non-null object \n", + " 17 report_year 244795 non-null int32 \n", + " 18 plant_name_eia_y 244795 non-null object \n", + " 19 city 238724 non-null object \n", + " 20 county 234116 non-null object \n", + " 21 latitude 241615 non-null float64 \n", + " 22 longitude 244380 non-null float64 \n", + " 23 state 244727 non-null object \n", + " 24 street_address 230464 non-null object \n", + " 25 zip_code 238119 non-null object \n", + " 26 timezone 244795 non-null object \n", + "dtypes: datetime64[ns](1), float64(8), int32(1), int64(4), object(13)\n", + "memory usage: 49.5+ MB\n" ] } ], @@ -201,7 +252,23 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, + "id": "b0427df6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "85e7f93e", + "metadata": {}, + "source": [ + "# Make Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "id": "2263e630-e9ae-4bcd-9a96-ca774c8bb1ee", "metadata": { "tags": [] @@ -209,13 +276,24 @@ "outputs": [], "source": [ "def plot_state_generation(generation: pd.DataFrame, state:str, publish=False, local=True):\n", - " state_generation = generation.query(\"state == @state\")\n", - "\n", - " fuel_type_grp = state_generation.groupby([\"report_date\", \"fuel_type_code_pudl\"])[\"net_generation_mwh\"].sum().reset_index()\n", + " fuel_type_grp = (\n", + " generation\n", + " .query(\"state == @state\")\n", + " .groupby([\"report_date\", \"report_year\", \"fuel_type_code_pudl\"])\n", + " [\"net_generation_mwh\"]\n", + " .sum()\n", + " .reset_index()\n", + " )\n", + " \n", + " sorted_fuel_types_df = (\n", + " fuel_type_grp\n", + " .query(f\"report_year == {fuel_type_grp.report_year.max()}\")\n", + " .sort_values(\"net_generation_mwh\", ascending=False)\n", + " )\n", "\n", " traces = []\n", "\n", - " for fuel_type in generation.fuel_type_code_pudl.unique():\n", + " for fuel_type in sorted_fuel_types_df.fuel_type_code_pudl:\n", " fuel_type_net_gen = fuel_type_grp.query(\"fuel_type_code_pudl == @fuel_type\")\n", " generation_gwh = (fuel_type_net_gen.net_generation_mwh / 1_000).round(decimals=0).astype(\"Int64\")\n", " traces.append(go.Scatter(\n", @@ -227,7 +305,7 @@ " ))\n", "\n", " fig = go.Figure(data=traces)\n", - " # fig.update_layout(showlegend=False)\n", + "# fig.update_layout(showlegend=False)\n", " fig.update_layout(legend=dict(\n", " yanchor=\"top\",\n", " y=0.99,\n", @@ -238,13 +316,15 @@ " margin=dict(l=20, r=20, t=20, b=20),\n", " )\n", " fig.update_layout({\n", - " # \"plot_bgcolor\": \"rgba(0, 0, 0, 0)\",\n", - " \"paper_bgcolor\": \"rgba(0, 0, 0, 0)\",\n", + " # \"plot_bgcolor\": \"rgba(0, 0, 0, 0)\",\n", + " \"paper_bgcolor\": \"rgba(0, 0, 0, 0)\",\n", " })\n", " fig.update_layout(\n", " xaxis_title=\"Years\",\n", " yaxis_title=\"Gigawatt Hours (Gwh)\",\n", " hovermode='x',\n", + " # for format see https://d3js.org/d3-format\n", + " # ,.2r is grouped thousands with two significant digits, \"4,200\"\n", " yaxis_tickformat=\",.2r\"\n", " )\n", " if local:\n", @@ -255,17 +335,46 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 10, "id": "b3b73206-64f2-4167-b154-edaf44e8d69a", "metadata": { "tags": [] }, "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { "application/vnd.plotly.v1+json": { "config": { - "plotlyServerURL": "https://plotly.com" + "plotlyServerURL": "https://plot.ly" }, "data": [ { @@ -313,7 +422,7 @@ ] ] }, - "name": "hydro", + "name": "gas", "stackgroup": "one", "type": "scatter", "x": [ @@ -341,28 +450,28 @@ "2022-01-01T00:00:00" ], "y": [ - 1200, - 1123, - 894, - 1301, - 1333, - 662, - 1644, - 1039, - 1029, - 1262, - 563, - 584, - 480, - 380, - 956, - 1342, - 1062, - 1126, - 1475, - 1046, - 1052, - 426 + 191110, + 197967, + 176385, + 188931, + 200731, + 201556, + 203132, + 196648, + 192716, + 189587, + 203281, + 216900, + 205296, + 206815, + 237597, + 228490, + 206984, + 241739, + 258468, + 249131, + 235077, + 250234 ] }, { @@ -410,7 +519,7 @@ ] ] }, - "name": "coal", + "name": "wind", "stackgroup": "one", "type": "scatter", "x": [ @@ -438,28 +547,28 @@ "2022-01-01T00:00:00" ], "y": [ - 136014, - 143137, - 147580, - 150131, - 149740, - 147992, - 148410, - 148048, - 140375, - 150760, - 158179, - 139481, - 150263, - 148350, - 120658, - 121345, - 134738, - 111791, - 91917, - 78913, - 88912, - 85432 + 646, + 2656, + 2570, + 3138, + 4237, + 6671, + 9006, + 16225, + 19953, + 26126, + 30500, + 31995, + 35874, + 39878, + 44833, + 57531, + 67022, + 75683, + 83541, + 92441, + 99474, + 113109 ] }, { @@ -507,7 +616,7 @@ ] ] }, - "name": "oil", + "name": "coal", "stackgroup": "one", "type": "scatter", "x": [ @@ -535,28 +644,28 @@ "2022-01-01T00:00:00" ], "y": [ - 1889, - 331, - 1592, - 260, - 201, - 189, - 178, - 117, - 137, - 121, - 136, - 91, - 92, - 102, - 101, - 82, - 74, - 61, - 54, - 48, - 204, - 200 + 136014, + 143137, + 147580, + 150131, + 149740, + 147992, + 148410, + 148048, + 140375, + 150760, + 158179, + 139481, + 150263, + 148350, + 120658, + 121345, + 134738, + 111791, + 91917, + 78913, + 88912, + 85432 ] }, { @@ -604,7 +713,7 @@ ] ] }, - "name": "gas", + "name": "nuclear", "stackgroup": "one", "type": "scatter", "x": [ @@ -632,28 +741,28 @@ "2022-01-01T00:00:00" ], "y": [ - 191110, - 197967, - 176385, - 188931, - 200731, - 201556, - 203132, - 196648, - 192716, - 189587, - 203281, - 216900, - 205296, - 206815, - 237597, - 228490, - 206984, - 241739, - 258468, - 249131, - 235077, - 250234 + 38163, + 35618, + 33437, + 40435, + 38232, + 41264, + 40955, + 40727, + 41498, + 41335, + 39648, + 38441, + 38315, + 39287, + 39355, + 42079, + 38581, + 41186, + 41298, + 41439, + 40211, + 41607 ] }, { @@ -701,19 +810,11 @@ ] ] }, - "name": "nuclear", + "name": "solar", "stackgroup": "one", "type": "scatter", "x": [ "2001-01-01T00:00:00", - "2002-01-01T00:00:00", - "2003-01-01T00:00:00", - "2004-01-01T00:00:00", - "2005-01-01T00:00:00", - "2006-01-01T00:00:00", - "2007-01-01T00:00:00", - "2008-01-01T00:00:00", - "2009-01-01T00:00:00", "2010-01-01T00:00:00", "2011-01-01T00:00:00", "2012-01-01T00:00:00", @@ -729,28 +830,20 @@ "2022-01-01T00:00:00" ], "y": [ - 38163, - 35618, - 33437, - 40435, - 38232, - 41264, - 40955, - 40727, - 41498, - 41335, - 39648, - 38441, - 38315, - 39287, - 39355, - 42079, - 38581, - 41186, - 41298, - 41439, - 40211, - 41607 + 0, + 8, + 29, + 118, + 145, + 257, + 401, + 731, + 2189, + 3206, + 4365, + 8537, + 14889, + 22168 ] }, { @@ -895,11 +988,19 @@ ] ] }, - "name": "solar", + "name": "hydro", "stackgroup": "one", "type": "scatter", "x": [ "2001-01-01T00:00:00", + "2002-01-01T00:00:00", + "2003-01-01T00:00:00", + "2004-01-01T00:00:00", + "2005-01-01T00:00:00", + "2006-01-01T00:00:00", + "2007-01-01T00:00:00", + "2008-01-01T00:00:00", + "2009-01-01T00:00:00", "2010-01-01T00:00:00", "2011-01-01T00:00:00", "2012-01-01T00:00:00", @@ -915,20 +1016,28 @@ "2022-01-01T00:00:00" ], "y": [ - 0, - 8, - 29, - 118, - 145, - 257, - 401, - 731, - 2189, - 3206, - 4365, - 8537, - 14889, - 22168 + 1200, + 1123, + 894, + 1301, + 1333, + 662, + 1644, + 1039, + 1029, + 1262, + 563, + 584, + 480, + 380, + 956, + 1342, + 1062, + 1126, + 1475, + 1046, + 1052, + 426 ] }, { @@ -1073,7 +1182,7 @@ ] ] }, - "name": "wind", + "name": "oil", "stackgroup": "one", "type": "scatter", "x": [ @@ -1101,33 +1210,32 @@ "2022-01-01T00:00:00" ], "y": [ - 646, - 2656, - 2570, - 3138, - 4237, - 6671, - 9006, - 16225, - 19953, - 26126, - 30500, - 31995, - 35874, - 39878, - 44833, - 57531, - 67022, - 75683, - 83541, - 92441, - 99474, - 113109 + 1889, + 331, + 1592, + 260, + 201, + 189, + 178, + 117, + 137, + 121, + 136, + 91, + 92, + 102, + 101, + 82, + 74, + 61, + 54, + 48, + 204, + 200 ] } ], "layout": { - "autosize": true, "hovermode": "x", "legend": { "x": 0.01, @@ -1959,35 +2067,22 @@ } }, "xaxis": { - "autorange": true, - "range": [ - "2001-01-01", - "2022-01-01" - ], "title": { "text": "Years" - }, - "type": "date" + } }, "yaxis": { - "autorange": true, - "range": [ - 0, - 541272.6315789474 - ], "tickformat": ",.2r", "title": { "text": "Gigawatt Hours (Gwh)" - }, - "type": "linear" + } } } }, - "image/png": "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", "text/html": [ - "