probability.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "tags": []
   },
   "source": [
    "# Probability and land-use\n",
    "\n",
    "The introduction of a threshhold value for beach-litter density by the EU and the reasons for the application of that threshhold mark a change in the importance and use of beach litter data. Prior to the establishment of a threshold the primary use of beach-litter data was to _educate_ the public and in some instances define a link with mortality and mobidity of marine species. At present beach-litter survey results are also considered on the numerical distance from a stated goal. That goal is defined in __pieces of trash for every 100 m__. The goal is based on the principal of precaution, that means we are unsure of the long term consequences of exposure to plastics and it would be best to minimize exposure if possible.[EU Threshold Value for Macro Litter on Coastlines](https://mcc.jrc.ec.europa.eu/main/dev.py?N=41&O=454)\n",
    "\n",
    "With the announcement of a threshhold value __there was no subsequent recomendation for changing the methods of sampling__. Consequently, this environmental assessment relies on the recorded observations of volunteers following a standard protocol. According to the journal [Nature](https://www.nature.com/articles/s41893-019-0390-3), programs that include the involvement of citizens in scientific research and/or knowledge production, can complement and ultimately improve the Sustainale Development Goals (SDG) reporting process. Beach litter applies specifically to SDG 14, __the target of achieving substantial reductions in marine pollution__. \n",
    "\n",
    "## Motivation\n",
    "\n",
    "The preceding sections demonstrate that there is a relationship between the enivironmental conditions (land-use) and the amount and types of objects found on the shoreline of Swiss rivers and lakes. However, a positive or negative correlation is only an indicator of the nature of a relationship. If we want to know to what degree we are more likely to find an object under one object or another under different conditions then further analysis must be conducted. As long as the test is used as an indicator it may help define more fruitfull avenues of inquiry.\n",
    "\n",
    "\n",
    "### Proposition\n",
    "\n",
    "If an object is positively correlated to a land-use attribute then we should expect to find more of that object when a survey is conducted at locations where that attribute is the most dominant. For example, given that cigarette end are positively correlated to buildings and urbanization we should expect to find more cigarette ends at locations that are primarily urban. Furthermore, we should expect to find less cigarette ends at locations where there are less buildings and more undefined land use, see section three correlation table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "%load_ext watermark\n",
    "# sys, file and nav packages:\n",
    "import datetime as dt\n",
    "import typing\n",
    "\n",
    "# math packages:\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.stats import beta\n",
    "\n",
    "# charting:\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from IPython.display import Markdown as md\n",
    "from IPython.display import display\n",
    "from myst_nb import glue\n",
    "\n",
    "\n",
    "def count_nk_bin(data, locations, agg={\"k\":\"sum\",\"n\":\"sum\"}):\n",
    "    \n",
    "    return data.loc[locations].agg(agg)\n",
    "\n",
    "def retrieve_locations_by_bin(data, value=\"use\", columns=[\"use\", \"binned\"], use=\"Fels\"):\n",
    "    d = data[data[value] == use]\n",
    "    d = d.groupby(columns, as_index=False, dropna=False).location.unique()\n",
    "    return d.dropna()\n",
    "\n",
    "def collect_odds_frequency(data):\n",
    "    data[\"odds\"] = data[\"k\"]/(data[\"n\"] - data[\"k\"])\n",
    "    data[\"frequency\"] = data[\"k\"]/data[\"n\"]\n",
    "    \n",
    "    return data\n",
    "\n",
    "def collect_bin_data(tested, xtest, value=\"use\"):\n",
    "    use = xtest[value].unique()\n",
    "    binned = xtest.binned.unique()\n",
    "    locations = xtest.location.values\n",
    "    \n",
    "    bins = []\n",
    "    \n",
    "    for i, anarray in enumerate(locations):\n",
    "        \n",
    "        a_count = count_nk_bin(tested, anarray)\n",
    "        a_count[value] = use[0]\n",
    "        a_count[\"binned\"] = binned[i]\n",
    "        bins.append(a_count)\n",
    "    return bins\n",
    "\n",
    "def n_and_k_for_a_set_of_landuse_data(tested, binned_land_use_data, value=\"use\", value_vars=[\"use\", \"binned\"]):\n",
    "    \n",
    "    binned = []\n",
    "    for use in binned_land_use_data[value].unique():\n",
    "        locations_by_bin = retrieve_locations_by_bin(binned_land_use_data, columns=value_vars, value=value, use=use)\n",
    "        bin_totals = collect_bin_data(tested, locations_by_bin, value=value)\n",
    "        \n",
    "        binned += bin_totals\n",
    "        \n",
    "        \n",
    "    df = pd.DataFrame(binned)\n",
    "    df = df.groupby(value_vars, as_index=False).agg({\"k\":\"sum\",\"n\":\"sum\"})\n",
    "    return df\n",
    "\n",
    "# survey data:\n",
    "dfBeaches = pd.read_csv(\"resources/beaches.csv\")\n",
    "dfCodes = pd.read_csv(\"resources/codes_with_group_names_2015.csv\")\n",
    "\n",
    "# set the index of the beach data to location slug\n",
    "dfBeaches.set_index('location', inplace=True)\n",
    "\n",
    "# set the index of to codes\n",
    "dfCodes.set_index(\"code\", inplace=True)\n",
    "\n",
    "# code description map\n",
    "code_d_map = dfCodes.description.copy()\n",
    "\n",
    "# shorten the descriptions of two codes\n",
    "code_d_map.loc[\"G38\"] = \"sheeting for protecting large cargo items\"\n",
    "code_d_map.loc[\"G73\"] = \"Foamed items & pieces (non packaging/insulation)\"\n",
    "\n",
    "# code material map\n",
    "code_m_map = dfCodes.material\n",
    "\n",
    "# this defines the css rules for the note-book table displays\n",
    "header_row = {'selector': 'th:nth-child(1)', 'props': f'background-color: #FFF; text-align:right'}\n",
    "even_rows = {\"selector\": 'tr:nth-child(even)', 'props': f'background-color: rgba(139, 69, 19, 0.08);'}\n",
    "odd_rows = {'selector': 'tr:nth-child(odd)', 'props': 'background: #FFF;'}\n",
    "table_font = {'selector': 'tr', 'props': 'font-size: 12px;'}\n",
    "table_data = {'selector': 'td', 'props': 'padding: 6px;'}\n",
    "table_caption = {'selector': 'caption', 'props': 'font-size: 14px; font-style: italic; caption-side: bottom; text-align: left; margin-top: 10px'}\n",
    "table_css_styles = [even_rows, odd_rows, table_font, header_row, table_caption]\n",
    "\n",
    "pdtype = pd.core.frame.DataFrame\n",
    "pstype = pd.core.series.Series\n",
    "\n",
    "cmap = sns.diverging_palette(230, 20, as_cmap=True)\n",
    "\n",
    "df = pd.read_csv('resources/surveys_iqaasl.csv')\n",
    "\n",
    "# the lakes of interest\n",
    "# collection points would be a good\n",
    "# label. This is how they are considered in the model\n",
    "# these locations serve as the endpoint for many \n",
    "# small rivers\n",
    "collection_points = [\n",
    "    'zurichsee',\n",
    "    'bielersee',\n",
    "    'neuenburgersee',\n",
    "    'walensee',\n",
    "    'vierwaldstattersee',\n",
    "    'brienzersee',\n",
    "    'thunersee',\n",
    "    'lac-leman',\n",
    "    'lago-maggiore',\n",
    "    'lago-di-lugano',\n",
    "    'zugersee'\n",
    "]\n",
    "\n",
    "# the data-frame of survey results to be considered\n",
    "df = df[df.feature.isin(collection_points)]\n",
    "\n",
    "# map the location to the name of the lake\n",
    "wn_map = df[[\"location\", \"feature\"]].drop_duplicates(\"location\").set_index(\"location\")\n",
    "wn_map = wn_map[\"feature\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "# these are the land use values for each hex\n",
    "# nutuzungsareal and freizeit areal are totaled\n",
    "# the surface area of these two use cases gets added\n",
    "# to the total of the land cover surface area\n",
    "dfln = pd.read_csv(\"resources/hex-3000m-cleaned/lake-locations-nutuzungsareal.csv\")\n",
    "dflf = pd.read_csv(\"resources/hex-3000m-cleaned/lake-locations-freizeitareal.csv\")\n",
    "\n",
    "# rename the columns and total the surface are for each component\n",
    "dflf.rename(columns={\"OBJEKTART\":\"use\"}, inplace=True)\n",
    "dflf = dflf[~dflf.use.isin(['Reben', 'Obstanlage'])].copy()\n",
    "dflf_t = dflf.groupby([\"location\", \"river_bass\", \"city\", \"feature\"], as_index=False).surface.sum()\n",
    "dflf_t[\"use\"] = \"recreation\"\n",
    "\n",
    "dfln.rename(columns={\"OBJEKTART\":\"use\"}, inplace=True)\n",
    "dfln = dfln[~dfln.use.isin(['Reben', 'Obstanlage'])].copy()\n",
    "dfln_t = dfln.groupby([\"location\", \"river_bass\", \"city\", \"feature\"], as_index=False).surface.sum()\n",
    "dfln_t[\"use\"] = \"infrastructure\"\n",
    "\n",
    "# combine the data frames\n",
    "rec_inf = pd.concat([dfln_t, dflf_t])\n",
    "rec_inf = rec_inf[rec_inf.location.isin(collection_points)]\n",
    "\n",
    "# this is the land cover, the total surface area of the hex is accounted for here\n",
    "# this includes the surface area of the lake within the hex\n",
    "# there are portions of the map layer that have no land-use attribute\n",
    "# to account for this, the total surface area of all labeled sections is \n",
    "# substracted from the area of a hex 5845672 m². This attribute is labled \n",
    "# undefined\n",
    "dflc = pd.read_csv(\"resources/hex-3000m-cleaned/lake-locations-landcover.csv\")\n",
    "\n",
    "# sum the unique land cover values for each location\n",
    "area_of_a_hex = 5845672\n",
    "xgr = dflc.groupby([\"location\", \"city\", \"river_bass\",\"lat\", \"lon\", \"feature\", \"OBJVAL\"], as_index=False, dropna=False).surface.sum()\n",
    "\n",
    "# the sum of all the land cover values for a location\n",
    "xgrt = xgr.groupby([\"location\", \"city\", \"river_bass\",\"lat\", \"lon\", \"feature\"], as_index=False).surface.sum()\n",
    "\n",
    "# the amount of surface area that is not accounted for \n",
    "xgrt[\"undefined\"] = area_of_a_hex - xgrt.surface\n",
    "\n",
    "# format data frame to join to the other land cover totals\n",
    "xgrt[\"OBJVAL\"] = \"undefined\"\n",
    "xgrt[\"surface\"] = xgrt[\"undefined\"]\n",
    "xgrt.drop(\"undefined\", inplace=True, axis=1)\n",
    "\n",
    "# add to other totals\n",
    "dflcx = pd.concat([xgr, xgrt])\n",
    "\n",
    "# remove the value of See from the surface area of a hex.\n",
    "# We are considering the magnitude of land use type in relation\n",
    "# to the amount of land that is available to be used, not including \n",
    "# amount of land that is covered by the lake itself\n",
    "xsee = xgr[xgr.OBJVAL == \"See\"][[\"location\", \"surface\"]]\n",
    "xsee[\"hex minus\"] = area_of_a_hex - xsee.surface\n",
    "hex_minus = xsee[[\"location\", \"hex minus\"]].set_index(\"location\", drop=True)\n",
    "\n",
    "# map the adjusted surface area to to the land use\n",
    "# totals and scale the surface column to the adjusted surface area\n",
    "dflcx[\"hex minus\"] = dflcx.location.apply(lambda x: hex_minus.loc[x, \"hex minus\"])\n",
    "# change column name\n",
    "dflcx.rename(columns={\"OBJVAL\":\"use\"}, inplace=True)\n",
    "\n",
    "# add the land use attributes to the land-cover data\n",
    "rec_inf[\"hex minus\"] = rec_inf.location.apply(lambda x: hex_minus.loc[x, \"hex minus\"])\n",
    "\n",
    "columns = [\"location\", \"river_bass\", \"city\", \"feature\", \"surface\", \"use\", \"hex minus\"]\n",
    "\n",
    "agg_land_use = pd.concat([dflcx[columns], rec_inf[columns]])\n",
    "\n",
    "agg_land_use[\"scaled\"] = agg_land_use.surface/agg_land_use[\"hex minus\"]\n",
    "\n",
    "# remove See from the data frame\n",
    "agg_land_use = agg_land_use[agg_land_use.use != \"See\"]\n",
    "\n",
    "bind = pd.IntervalIndex.from_tuples([(-1, 0), (0.00000001, .049999), (.05000, .099999), (.10000, .149999),(.15000, .199999), (.2, .2499), (.25, .2999), (.3000, .3499),\n",
    "        (.35, .3999), (.4000, .449999), (.45, .499999),(.5, .549999), (.55, .5999), (.6000, .6499), (.65, .6999), (.7, .7499), (.75, .7999),\n",
    "        (.8, .8499), (.85, .8999), (.9, .9499), (.95, 1)])\n",
    "\n",
    "# bin the scaled column\n",
    "sbins = pd.cut(agg_land_use.scaled, bins=bind, labels=np.arange(start=0, stop=21), include_lowest=True, retbins=False)\n",
    "sbins=sbins.cat.rename_categories(np.arange(start=0, stop=21))\n",
    "\n",
    "agg_land_use[\"binned\"] = sbins\n",
    "\n",
    "# land use features that get laid on top of the land-cover features\n",
    "# the distance ot the river intersections and the length of the river\n",
    "# features in the hexgon\n",
    "dist_ct = pd.read_csv(\"resources/hex-3000m-cleaned/river-intersect-length.csv\")\n",
    "dist_dt = dist_ct.groupby(\"location\", as_index=False).agg({\"distance\":\"mean\", \"length\":\"sum\"})\n",
    "dist_dt = dist_dt[dist_dt.location.isin(df.location.unique())].copy()\n",
    "dist_dt = pd.melt(dist_dt, id_vars = \"location\", value_vars=[\"length\", \"distance\"])\n",
    "\n",
    "# min max scale\n",
    "dist_dt[\"scaled\"] = (dist_dt[\"value\"] - dist_dt[\"value\"].min())/(dist_dt[\"value\"].max() - dist_dt[\"value\"].min())\n",
    "# bin in groups of 0.05 plus one bin for zero\n",
    "sbinsr = pd.cut(dist_dt.scaled, bins=bind, labels=np.arange(start=0, stop=21), include_lowest=True, retbins=False)\n",
    "sbinsr=sbinsr.cat.rename_categories(np.arange(start=0, stop=21))\n",
    "dist_dt[\"binned\"] = sbinsr\n",
    "\n",
    "# add the survey area and feature name to the data\n",
    "rbas_map = df[[\"location\", \"river_bassin\"]].drop_duplicates([\"location\", \"river_bassin\"]).set_index(\"location\")\n",
    "rbas_map = rbas_map[\"river_bassin\"]\n",
    "dist_dt[\"feature\"] = dist_dt.location.apply(lambda x: wn_map.loc[x])\n",
    "dist_dt[\"river_bass\"] = dist_dt.location.apply(lambda x: rbas_map.loc[x])\n",
    "\n",
    "# the length of the road network in the hex\n",
    "strasse = pd.read_csv(\"resources/hex-3000m-cleaned/lake-locations-strasse.csv\")\n",
    "strasse = strasse[strasse.location.isin(df.location.unique())].copy()\n",
    "stras = strasse.groupby([\"location\",\"river_bass\", \"city\", \"feature\",  ], as_index=False).length.sum()\n",
    "\n",
    "# min max scale\n",
    "stras[\"scaled\"] = (stras[\"length\"] - stras[\"length\"].min())/(stras[\"length\"].max() - stras[\"length\"].min())\n",
    "# bin\n",
    "sbinsras = pd.cut(stras.scaled, bins=bind, labels=np.arange(start=0, stop=21), include_lowest=True, retbins=False)\n",
    "sbinsras=sbinsras.cat.rename_categories(np.arange(start=0, stop=21))\n",
    "stras[\"binned\"] = sbinsras\n",
    "stras[\"use\"] = \"Strasse\"\n",
    "\n",
    "mix_agg = agg_land_use.copy()\n",
    "mix_agg[\"binned\"] = mix_agg.binned.astype('int')\n",
    "mix_agg.drop_duplicates([\"location\", \"use\"], inplace=True)\n",
    "mix_agg_scale_key = mix_agg[[\"location\", \"river_bass\", \"feature\", \"use\", \"surface\", \"scaled\", \"binned\"]].set_index(\"location\")\n",
    "mix_agg_scale_key.rename(columns={\"surface\":\"magnitude\"}, inplace=True)\n",
    "mix_agg_scale_key\n",
    "\n",
    "mix_dt = dist_dt.copy()\n",
    "mix_dt[\"binned\"] = mix_dt.binned.astype('int')\n",
    "mix_dt.drop_duplicates([\"location\", \"variable\"], inplace=True)\n",
    "mix_dt_scale_key = mix_dt[[\"location\", \"river_bass\", \"feature\", \"variable\", \"value\", \"scaled\", \"binned\"]].set_index(\"location\")\n",
    "mix_dt_scale_key.rename(columns={\"variable\":\"use\"}, inplace=True)\n",
    "mix_dt_scale_key.rename(columns={\"value\":\"magnitude\"}, inplace=True)\n",
    "mix_dt_scale_key\n",
    "\n",
    "strass_dt_scale_key = stras[[\"location\", \"river_bass\", \"feature\", \"use\", \"length\", \"scaled\", \"binned\"]].copy()\n",
    "strass_dt_scale_key[\"binned\"] = strass_dt_scale_key.binned.astype(int)\n",
    "strass_dt_scale_key.rename(columns={\"length\":\"magnitude\"}, inplace=True)\n",
    "strass_dt_scale_key.set_index(\"location\", inplace=True, drop=True)\n",
    "\n",
    "land_use_keys = pd.concat([strass_dt_scale_key, mix_dt_scale_key, mix_agg_scale_key])\n",
    "land_use_keys.reset_index(drop=False, inplace=True)\n",
    "land_use_keys = land_use_keys[land_use_keys.location.isin(df.location.unique())]\n",
    "lusek_copy = land_use_keys.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The probability of finding a cigarette end\n",
    "\n",
    "We test the proposition by constructing a discrete grid approximation of the probability of finding an on object under two different conditions.\n",
    "\n",
    "1. The probability of finding a cigarette end when the land-use is mostly buildings\n",
    "2. The probability of finding a cigarette end when the land-use is mostly undefined\n",
    "\n",
    "There five steps to constructing a grid approximation:\n",
    "\n",
    "1. Discretize the parameter space if it is not already discrete.\n",
    "2. Compute prior and likelihood at each “grid point” in the (discretized) parameter space.\n",
    "3. Compute (kernel of) posterior as prior ⋅\n",
    "4. likelihood at each “grid point”.\n",
    "5. Normalize to get posterior, if desired.\n",
    "\n",
    "For this manuscript we are not detailing the construction of the grid. Note that the same data in section three is used here. If you would like to know how this is done in detail follow the one the links. Users of _R_ should select _Krushke_ or _Bayes rules_, python users should follow _Think Bayes_. [Krushke](https://rpruim.github.io/Kruschke-Notes/bayes-rule-and-the-grid-method.html), [Bayes rules](https://www.bayesrulesbook.com/chapter-6.html), [Think Bayes](https://www.bayesrulesbook.com/chapter-6.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cigs = df[df.code == \"G27\"].copy()\n",
    "sied = lusek_copy[lusek_copy.use == \"Siedl\"].pivot(columns=\"use\", index=\"location\", values=\"magnitude\")\n",
    "wald = lusek_copy[lusek_copy.use == \"undefined\"].pivot(columns=\"use\", index=\"location\", values=\"magnitude\")\n",
    "\n",
    "cigs = cigs.merge(sied, left_on=\"location\", right_index=True, validate=\"many_to_one\")\n",
    "cigs = cigs.merge(wald, left_on=\"location\", right_index=True, validate=\"many_to_one\")\n",
    "cigs = cigs[[\"loc_date\", \"code\", \"pcs_m\", \"Siedl\", \"undefined\"]]\n",
    "\n",
    "med_wald = cigs.undefined.median()\n",
    "med_siedl = cigs.Siedl.median()\n",
    "\n",
    "more_city = cigs[cigs.Siedl > med_siedl]\n",
    "more_woods = cigs[cigs.undefined > med_wald]\n",
    "\n",
    "xrange = np.arange(0, 10.01, step=.01)\n",
    "def when_k_is_zero_or_equal_to_n(k, n):\n",
    "    if k == n:\n",
    "        return (k, n-k+1)\n",
    "    elif k == 0:\n",
    "        return (k+1, n-k+1)\n",
    "    else:\n",
    "        return (k, n-k)\n",
    "\n",
    "def n_k_per_set(data, xrange):\n",
    "    \n",
    "    d = data.pcs_m.values\n",
    "    kn =[beta(*when_k_is_zero_or_equal_to_n((d >= x).sum(), len(d))).mean() for x in xrange]\n",
    "    \n",
    "        \n",
    "    return kn\n",
    "\n",
    "p_woods = n_k_per_set(more_woods, xrange)\n",
    "p_siedl = n_k_per_set(more_city, xrange)\n",
    "\n",
    "combined = pd.DataFrame({\"undefined\":p_woods, \"city\":p_siedl}, index=xrange)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7,6))\n",
    "\n",
    "\n",
    "sns.scatterplot(x=xrange, y=p_woods, label=\"More undefined land use\")\n",
    "sns.scatterplot(x=xrange, y=p_siedl, label=\"More buildings\")\n",
    "\n",
    "ax.set_xlim(-.5, 8)\n",
    "\n",
    "ax.set_ylabel(\"Probability that a survey will be greater than x\")\n",
    "ax.set_xlabel(\"x = pieces of trash per meter\")\n",
    "ax.set_title(\"Grid approximation of the probability of finding cigarette ends\\nTwo conditions: more buildings or more undefined  land-use\", loc=\"left\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpretation\n",
    "\n",
    "Locations with a greater percentage of land attributed to buildings have a higher probability of returning survey results with more cigarette ends. The difference is greates on the range of $\\approx$ 0.2 pcs/m to 5 pcs/m."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "\n",
       "This script updated 09/08/2023 in Biel, CH\n",
       "\n",
       "> ❤️ what you do everyday\n",
       "\n",
       "*analyst at hammerdirt*\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "today = dt.datetime.now().date().strftime(\"%d/%m/%Y\")\n",
    "where = \"Biel, CH\"\n",
    "\n",
    "my_block = f\"\"\"\n",
    "\n",
    "This script updated {today} in {where}\n",
    "\n",
    "> \\u2764\\ufe0f what you do everyday\n",
    "\n",
    "*analyst at hammerdirt*\n",
    "\"\"\"\n",
    "\n",
    "md(my_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Git repo: https://github.com/hammerdirt-analyst/landuse.git\n",
      "\n",
      "Git branch: main\n",
      "\n",
      "seaborn   : 0.12.2\n",
      "numpy     : 1.24.2\n",
      "pandas    : 2.0.0\n",
      "matplotlib: 3.7.1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%watermark --iversions -b -r"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}