KarrLab/wc_lang

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Expression utils demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from wc_lang import SpeciesType, Species, Function, Observable, Parameter\n",
    "from wc_lang.expression_utils import WcLangExpression, WcLangExpressionError, TokCodes\n",
    "\n",
    "objects = {\n",
    "            Species: {'test_id[c]':Species(), 'x_id[c]':Species()},\n",
    "            Parameter: {'test_id':Parameter(), 'param_id':Parameter()},\n",
    "            Observable: {'test_id':Observable(), 'obs_id':Observable()},\n",
    "            Function: {'fun_1':Function(), 'fun_2':Function()}\n",
    "        }\n",
    "\n",
    "def make_wc_lang_expr(expr, obj_type=Function):\n",
    "    objs = {}\n",
    "    for o_type, value in objects.items():\n",
    "        if o_type.__name__ in obj_type.Meta.valid_used_models:\n",
    "            objs[o_type] = value\n",
    "    return WcLangExpression(obj_type, 'expr_attr', expr, objs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Illustrate Python tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TokenInfo(type=2 (NUMBER), string='3', start=(1, 0), end=(1, 1), line='3 * 4 + identifier')\n",
      "TokenInfo(type=53 (OP), string='*', start=(1, 2), end=(1, 3), line='3 * 4 + identifier')\n",
      "TokenInfo(type=2 (NUMBER), string='4', start=(1, 4), end=(1, 5), line='3 * 4 + identifier')\n",
      "TokenInfo(type=53 (OP), string='+', start=(1, 6), end=(1, 7), line='3 * 4 + identifier')\n",
      "TokenInfo(type=1 (NAME), string='identifier', start=(1, 8), end=(1, 18), line='3 * 4 + identifier')\n"
     ]
    }
   ],
   "source": [
    "wc_lang_expr = make_wc_lang_expr('3 * 4 + identifier')\n",
    "for token in wc_lang_expr.tokens:\n",
    "    print(token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## tokenize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_2 = make_wc_lang_expr('2 * fun_1() + obs_id')\n",
    "expr_2.tokenize()\n",
    "assert expr_2.errors == []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Illustrate WC-Lang tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Token codes used in parsed expressions \n",
      "wc_lang_obj_id\n",
      "math_fun_id\n",
      "other\n"
     ]
    }
   ],
   "source": [
    "print(TokCodes.__doc__)\n",
    "for tok_code in TokCodes:\n",
    "    print(tok_code.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WcLangToken(tok_code=<TokCodes.other: 3>, token_string='2', model_type=None, model_id=None, model=None)\n",
      "WcLangToken(tok_code=<TokCodes.other: 3>, token_string='*', model_type=None, model_id=None, model=None)\n",
      "WcLangToken(tok_code=<TokCodes.wc_lang_obj_id: 1>, token_string='fun_1', model_type=<class 'wc_lang.core.Function'>, model_id='fun_1', model=<wc_lang.core.Function object at 0x7f03f809c0f0>)\n",
      "WcLangToken(tok_code=<TokCodes.other: 3>, token_string='(', model_type=None, model_id=None, model=None)\n",
      "WcLangToken(tok_code=<TokCodes.other: 3>, token_string=')', model_type=None, model_id=None, model=None)\n",
      "WcLangToken(tok_code=<TokCodes.other: 3>, token_string='+', model_type=None, model_id=None, model=None)\n",
      "WcLangToken(tok_code=<TokCodes.wc_lang_obj_id: 1>, token_string='obs_id', model_type=<class 'wc_lang.core.Observable'>, model_id='obs_id', model=<wc_lang.core.Observable object at 0x7f03f802de80>)\n"
     ]
    }
   ],
   "source": [
    "for wc_token in expr_2.wc_tokens:\n",
    "    print(wc_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_2.test_eval_expr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Disambiguate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"'test_id + obs_id', a Function.expr_attr, contains multiple model object id matches: 'test_id' as a Observable id, 'test_id' as a Parameter id\"]\n"
     ]
    }
   ],
   "source": [
    "expr_3 = make_wc_lang_expr('test_id + obs_id')\n",
    "expr_3.tokenize()\n",
    "print(expr_3.errors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_4 = make_wc_lang_expr('Observable.test_id + Parameter.test_id + obs_id')\n",
    "expr_4.tokenize()\n",
    "assert expr_4.errors == []\n",
    "expr_4.test_eval_expr(test_val=2.0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}