dssg · thcrock · Apr 16, 2022 · Apr 16, 2022 · Apr 16, 2022 · Apr 16, 2022
diff --git a/example/config/cohort_size.ipynb b/example/config/cohort_size.ipynb
@@ -0,0 +1,109 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "921feeb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "d689c475",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from datetime import date\n",
+    "from matplotlib.ticker import MaxNLocator\n",
+    "\n",
+    "fig,axes=plt.subplots(1,1)\n",
+    "\n",
+    "x = np.asarray([\n",
+    "    date(2016, 1, 1),\n",
+    "    date(2016, 2, 1),\n",
+    "    date(2016, 3, 1),\n",
+    "    date(2016, 4, 1),\n",
+    "    date(2016, 5, 1),\n",
+    "    date(2016, 6, 1),\n",
+    "    date(2016, 7, 1),\n",
+    "    date(2016, 8, 1),\n",
+    "    date(2016, 9, 1),\n",
+    "    date(2016, 10, 1),\n",
+    "    date(2016, 11, 1),\n",
+    "    date(2016, 12, 1)\n",
+    "])\n",
+    "y = np.asarray([\n",
+    "    123,\n",
+    "    154,\n",
+    "    345,\n",
+    "    322,\n",
+    "    0,\n",
+    "    111,\n",
+    "    143,\n",
+    "    109,\n",
+    "    95,\n",
+    "    100,\n",
+    "    123,\n",
+    "    200\n",
+    "])\n",
+    "\n",
+    "plt.bar(x, y, 5)\n",
+    "axes.xaxis.set_major_locator(MaxNLocator(5)) \n",
+    "\n",
+    "plt.xlabel('Date')\n",
+    "plt.ylabel('Cohort Size')\n",
+    "plt.title('Cohort Size by Date')\n",
+    "plt.grid(False)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0baa4a58",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/requirement/main.txt b/requirement/main.txt
@@ -27,6 +27,7 @@ matplotlib==3.3.4
 pandas==1.0.5
 seaborn==0.10.1
 ohio==0.5.0
+pydantic==1.9.0
 
 
 aequitas==0.42.0
diff --git a/src/tests/architect_tests/test_plotting.py b/src/tests/architect_tests/test_plotting.py
@@ -0,0 +1,54 @@
+from datetime import datetime, timedelta
+import testing.postgresql
+from sqlalchemy.engine import create_engine
+
+from . import utils
+
+from triage.component.architect.plotting import inspect_cohort_query_on_date, CohortInspectionResults
+
+def test_inspect_cohort_query_on_date():
+    input_data = [
+        (1, datetime(2016, 1, 1), True),
+        (1, datetime(2016, 4, 1), False),
+        (1, datetime(2016, 3, 1), True),
+        (2, datetime(2016, 1, 1), False),
+        (2, datetime(2016, 1, 1), True),
+        (3, datetime(2016, 1, 1), True),
+        (5, datetime(2016, 3, 1), True),
+        (5, datetime(2016, 4, 1), True),
+    ]
+    with testing.postgresql.Postgresql() as postgresql:
+        engine = create_engine(postgresql.url())
+        utils.create_binary_outcome_events(engine, "events", input_data)
+        results = inspect_cohort_query_on_date(
+            db_engine=engine,
+            query="select entity_id from events where outcome_date < '{as_of_date}'::date",
+            as_of_date=datetime(2016, 2, 1)
+        )
+
+        expected_output = CohortInspectionResults(
+            ran_successfully=True,
+            num_rows=3,
+            num_distinct_entity_ids=3,
+            examples=[1, 2, 3]
+        )
+
+        assert results == expected_output
+
+def test_inspect_cohort_query_on_date_unsuccessful():
+    with testing.postgresql.Postgresql() as postgresql:
+        engine = create_engine(postgresql.url())
+        results = inspect_cohort_query_on_date(
+            db_engine=engine,
+            query="select entity_id from events2 where outcome_date < '{as_of_date}'::date",
+            as_of_date=datetime(2016, 2, 1)
+        )
+
+        expected_output = CohortInspectionResults(
+            ran_successfully=False,
+            num_rows=0,
+            num_distinct_entity_ids=0,
+            examples=[]
+        )
+
+        assert results == expected_output
diff --git a/src/triage/component/architect/plotting.py b/src/triage/component/architect/plotting.py
@@ -0,0 +1,48 @@
+import datetime
+import verboselogs
+from triage.component.architect.entity_date_table_generators import EntityDateTableGenerator
+from typing import List, Optional
+
+logger = verboselogs.VerboseLogger(__name__)
+
+import pydantic
+
+class CohortInspectionResults(pydantic.BaseModel):
+    ran_successfully: bool
+    num_rows: int
+    num_distinct_entity_ids: int
+    examples: List[str]
+
+def inspect_cohort_query_on_date(query: str, db_engine, as_of_date: datetime.date) -> CohortInspectionResults:
+    cohort_table_name = 'temp_inspect_cohort'
+    generator = EntityDateTableGenerator(
+        query=query,
+        db_engine=db_engine,
+        entity_date_table_name=cohort_table_name,
+        replace=True
+    )
+    results = {}
+    logger.info('Inspecting cohort query at %s', query)
+    try:
+        generator.generate_entity_date_table([as_of_date])
+        results['ran_successfully'] = True
+    except:
+        return CohortInspectionResults(
+            ran_successfully=False,
+            num_rows=0,
+            num_distinct_entity_ids=0,
+            examples=[]
+        )
+
+    results['num_rows'] = list(db_engine.execute(
+        f'select count(*) from {cohort_table_name} where as_of_date = %s',
+        as_of_date))[0][0]
+    results['num_distinct_entity_ids'] = list(db_engine.execute(
+        f'select count(distinct(entity_id)) from {cohort_table_name} where as_of_date = %s',
+        as_of_date))[0][0]
+
+    results['examples'] = sorted([
+        row[0]
+        for row in db_engine.execute(f'select entity_id from {cohort_table_name} ORDER BY random() limit 5')
+    ])
+    return CohortInspectionResults(**results)