sandbox - factory creators.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 2,
 "metadata": {
  "language_info": {
   "name": "python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "version": "3.6.8-final"
  },
  "orig_nbformat": 2,
  "file_extension": ".py",
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3,
  "kernelspec": {
   "name": "python36832bitvenvvenvb93cf92d5fe6482d9f0b0a9d194e1425",
   "display_name": "Python 3.6.8 32-bit ('.venv': venv)"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🏭🏭 Factory creators\n",
    "This noteobook experimentally implements a set of validator factory creators for common validator factory patterns using some ✨ magic to produce the messages from the different components.\n",
    "\n",
    "The goal with this proposed feature is to DRY and simplify how predefined validator factories are defined within this library:\n",
    "\n",
    "```pydfdf\n",
    "# cells.py\n",
    "\n",
    "all_eq = quantitative_validator_factory(vf.CellsValidator, R.all, R.equals)\n",
    "sum_eq = reductive_validator_factory(vf.CellsValidator, R.sum, R.equals)\n",
    "```\n",
    "\n",
    "Note that usage remains the same for downstream consumers:\n",
    "\n",
    "```py\n",
    "vf.cells.all_eq(0).validate(df)\n",
    "vf.cells.sum_eq(42).validate(df)\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable\n",
    "\n",
    "import ramda as R\n",
    "import validframe as vf\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "PREDICATES = {\n",
    "    R.equals: \"equal to {x}\",\n",
    "    R.is_: \"instance of type {x}\",\n",
    "    R.lt: \"less than to {x}\",\n",
    "    R.lte: \"less than or equal to {x}\",\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "QUANTIFIERS = {\n",
    "    R.all: \"all\",\n",
    "    R.any: \"any\",\n",
    "}\n",
    "\n",
    "REDUCERS = {\n",
    "    R.sum: \"sum\",\n",
    "    R.product: \"product\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quantitative_validator_factory(quantifier: Callable, predicate: Callable) -> Callable:\n",
    "    return lambda x, **slice_kwargs: vf.CellsValidator(\n",
    "        quantifier(predicate(x)),\n",
    "        '(slice={s}) {q} of the cells must be {c}'.format(s=slice_kwargs, q=QUANTIFIERS[quantifier], c=PREDICATES[predicate].format(x=repr(x)), ),\n",
    "        **slice_kwargs\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "\"(slice={'cols': ['amount']}) all of the cells must be equal to 1\""
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_eq = quantitative_validator_factory(R.all, R.equals)\n",
    "all_eq(1, cols=['amount']).msg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame([[1,1,1],[1,1,1],[2,2,2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def call_validators(df, validators):\n",
    "    try:\n",
    "        for validator in validators:\n",
    "            validator.validate(df)\n",
    "    except AssertionError as e:\n",
    "        print('failed:', e)\n",
    "    except Exception:\n",
    "        print('error:', 'something went wrong')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "call_validators(df, [\n",
    "    all_eq(1, rows=[0,1]),\n",
    "    all_eq(2, rows=[2])\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "any_eq = quantitative_validator_factory(R.any, R.equals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "failed: (slice={'cols': [0]}) any of the cells must be equal to nan\n"
    }
   ],
   "source": [
    "call_validators(df,[\n",
    "    any_eq(2, cols=[0]),\n",
    "    any_eq(np.nan, cols=[0])\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "error: something went wrong\n"
    }
   ],
   "source": [
    "# mismatched - should use reduction_validator for sum\n",
    "sum_eq = quantitative_validator_factory(R.sum, R.equals)\n",
    "\n",
    "try:\n",
    "    sum_eq(12)\n",
    "except Exception:\n",
    "    print('error:', 'something went wrong')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_eq = R.compose(R.equals, R.sum)\n",
    "sum_eq([1,2,3])(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_eq = lambda xs: R.equals(R.sum(xs))\n",
    "sum_eq([1,2,3])(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduction_validator(reducer: Callable, predicate: Callable) -> Callable:\n",
    "    return lambda x, **slice_kwargs: vf.CellsValidator(\n",
    "        R.compose(predicate(x), reducer),\n",
    "        '(slice={s}) {q} of the cells must be {c}'.format(s=slice_kwargs, q=REDUCERS[reducer], c=PREDICATES[predicate].format(x=repr(x)), ),\n",
    "        **slice_kwargs\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "'(slice={}) sum of the cells must be equal to 12'"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_eq = reduction_validator(R.sum, R.equals)\n",
    "\n",
    "sum_eq(12).msg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "failed: (slice={'rows': [0]}) sum of the cells must be equal to 12\n"
    }
   ],
   "source": [
    "sum_eq(12).validate(df)\n",
    "\n",
    "call_validators(df,[\n",
    "    sum_eq(12, rows=[0])\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_eq = quantitative_validator_factory(R.all, R.equals)\n",
    "all_is = quantitative_validator_factory(R.all, R.is_)\n",
    "all_lte = quantitative_validator_factory(R.all, R.lte)\n",
    "\n",
    "sum_eq = reduction_validator(R.sum, R.equals)\n",
    "sum_eq(12).validate(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "VALIDATORS = {\n",
    "    vf.CellsValidator: 'cells',\n",
    "    vf.RowsValidator: 'rows',\n",
    "}\n",
    "\n",
    "def reductive_validator_factory_next(validator_type = vf.CellsValidator, reducer: Callable, predicate: Callable) -> Callable:\n",
    "    return lambda x, **slice_kwargs: validator_type(\n",
    "        R.compose(predicate(x), reducer),\n",
    "        '(slice={s}) {q} of the {v} must be {c}'.format(s=slice_kwargs, q=REDUCERS[reducer], v=VALIDATORS[validator_type], c=PREDICATES[predicate].format(x=repr(x))),\n",
    "        **slice_kwargs\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "error: something went wrong, still...\n"
    }
   ],
   "source": [
    "# now we can sum rows\n",
    "sum_eq = reductive_validator_factory_next(R.sum, R.equals, vf.RowsValidator)\n",
    "\n",
    "try:\n",
    "    # rows are `pd.Series` and summing them also returns a `pd.Series`\n",
    "    expected_sum = pd.Series([4,4,4])\n",
    "    sum_eq(expected_sum).validate(df)\n",
    "except Exception:\n",
    "    print('error:', 'something went wrong, still...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "0    True\n1    True\n2    True\ndtype: bool"
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# just remember that applying `==` to `pd.Series` actually returns a mask, just like with `pd.DataFrame`\n",
    "pd.Series([4,4,4]) == pd.Series([4,4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for equality check we want this instead:\n",
    "pd.Series([4,4,4]).equals(pd.Series([4,4,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or better yet with the static method:\n",
    "pd.Series.equals(pd.Series([4,4,4]), pd.Series([4,4,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "passed: (slice={}) sum of the rows must be equal 0    4\n1    4\n2    4\ndtype: int64\n"
    }
   ],
   "source": [
    "# so putting it all together:\n",
    "R_series_equals = lambda y: lambda x: pd.Series.equals(y, x)\n",
    "PREDICATES[series_equals] = 'equal {x}'\n",
    "\n",
    "rows_sum_eq = reductive_validator_factory_next(R.sum, R_series_equals, vf.RowsValidator)\n",
    "\n",
    "rows_sum_eq(expected_sum).validate(df)\n",
    "print('passed:', rows_sum_eq(expected_sum).msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "[4, 4, 4]"
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we were jinja ninjas we could maybe make the message better\n",
    "PREDICATES[series_equals] = 'equal {{x.to_list()}}'\n",
    "\n",
    "expected_sum.to_list()"
   ]
  }
 ]
}