01/01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Technical Test 01\n",
    "\n",
    "## Database Schema Design\n",
    "\n",
    ">Q1.1. How can we link \"Task\" to an element of type either \"ItemA\" either \"ItemB\"? An explanation or a schema (drawing) will suffice.\n",
    "\n",
    "We can place the PK for ItemA and PK for ItemB in the Items table with either A or B as optional. However, it would violate 1NF of database normalization as there would be repeating groups of data.\n",
    "\n",
    "This would be more of a quick-and-dirty solution that would lead to technical debt in the future should more changes and complexity be needed.\n",
    "\n",
    "A better solution would be the answer below for Q1.2\n",
    "\n",
    "<img src=\"sql_schema_1.png\" />\n",
    "\n",
    ">Q1.2. How to modify the Task table so that each task element can be link to an item of any type (ItemA, ItemB, .. , ItemM, ItemN, ...).\n",
    "\n",
    "We can use a one-to-many non-optional relationship to isolate the ItemType of each Item, allowing an Item to be either A, B, C... but not allowing an Item to be both A or B at the same time.\n",
    "\n",
    "This would ensure that data is:\n",
    "- without repeating groups (1NF)\n",
    "- data is dependant on key (2NF)\n",
    "- without redundant data (3NF)\n",
    "\n",
    "<img src=\"sql_schema_2.png\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cleaning Strings\n",
    ">Q2.1. Write a function spaceCorrect that will take in input the text with errors (string), and will return as output the corrected text (string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dirty_input = 'M.   Charles Granger , hello?Are you there?!?'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M. Charles Granger, hello ? Are you there ? ! ? \n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "def _transform(group):\n",
    "    \"\"\"Accepts a string character group, iterates over each character in the group and adds spacing for punctuation rules.\n",
    "    \n",
    "    Args:\n",
    "        group (string): the string to transform.\n",
    "        \n",
    "    Returns:\n",
    "        string: transformed string with correct punctuation rules\n",
    "    \"\"\"\n",
    "    result = re.sub(r' *([.,]) *', lambda x: '{} '.format(x.group().strip()), group)\n",
    "    result = re.sub(r' *([?!:;]) *', lambda x: ' {} '.format(x.group().strip()), result)\n",
    "    return result\n",
    "\n",
    "def _fix_double_space(group):\n",
    "    \"\"\"Accepts a string character group, finds a double space in it and replaces it with a single space.\n",
    "    \n",
    "    Args:\n",
    "        group (string): the string to transform.\n",
    "    \n",
    "    Returns:\n",
    "        string: string without double spaces.\n",
    "    \"\"\"\n",
    "    if group.find('  ') > -1:\n",
    "        fixed = group.replace('  ', ' ')\n",
    "    return fixed\n",
    "\n",
    "def spaceCorrect(text):\n",
    "    \"\"\"Corrects spacing in a string according to punctuation rules\n",
    "    Args:\n",
    "        text (string): the string to correct\n",
    "    \n",
    "    Returns:\n",
    "        string: the corrected string\n",
    "    \"\"\"\n",
    "    # splits the input string by spaces to separate character groups\n",
    "#     groups = text.split(' ')\n",
    "    \n",
    "    #filters out empty strings\n",
    "#     no_empty_string = list(filter(lambda x: x != '', groups))\n",
    "    transformed = _transform(text)\n",
    "    # iterates over each character group and transforms them to correct punctuation\n",
    "#     with_space_after = [_transform(x) for x in no_empty_string]\n",
    "    \n",
    "    #joins back each character group with spaces between them\n",
    "#     joined = ' '.join(with_space_after)\n",
    "    \n",
    "    # before returning the result, we clean the string once more to fix double spacing\n",
    "    # which may be due to 2 symbols being next to each other\n",
    "    return _fix_double_space(transformed)\n",
    "\n",
    "print(spaceCorrect(dirty_input))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Q2.2. Write a function betterSpaceCorrect(text, correspondances) that will do the same job as in Q2.1, using this associative array as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "correspondances = {\n",
    "    \",\": [0, 1],\n",
    "    \".\": [0, 1],\n",
    "    \":\": [1, 1],\n",
    "    \";\": [1, 1],\n",
    "    \"!\": [1, 1],\n",
    "    \"?\": [1, 1]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def _better_transform(group, correspondances):\n",
    "    \"\"\"Accepts a string character group, iterates over each character in the group and adds spacing for punctuation rules.\n",
    "    \n",
    "    References a correspondances dictionary for punctuation rules\n",
    "    \n",
    "    Args:\n",
    "        group (string): the string to transform.\n",
    "        correspondances (dict): dictionary that specifies the punctuation rules.\n",
    "            Format of punctuation corresponds to [before, after]\n",
    "        \n",
    "    Returns:\n",
    "        string: transformed string with correct punctuation rules\n",
    "    \"\"\"\n",
    "#     result = []\n",
    "#     for char in group:\n",
    "#         if char in correspondances:\n",
    "#             #symbol with punctuation rule found\n",
    "#             result.append('{before}{character}{after}'.format(\n",
    "#                 before = ' '*correspondances[char][0],\n",
    "#                 character = char,\n",
    "#                 after = ' '*correspondances[char][1]))\n",
    "#         else:\n",
    "#             # no symbol with punctuation rule found\n",
    "#             result.append(char)\n",
    "#     return ''.join(result)\n",
    "    result = re.sub(r' *([.,?!:;]) *', lambda x: '{before}{character}{after}'.format(\n",
    "        before = ' '*correspondances[x.group().strip()][0],\n",
    "        character = x.group().strip(),\n",
    "        after = ' '*correspondances[x.group().strip()][1]), group)\n",
    "    \n",
    "    #             result.append('{before}{character}{after}'.format(\n",
    "#                 before = ' '*correspondances[char][0],\n",
    "#                 character = char,\n",
    "#                 after = ' '*correspondances[char][1]))\n",
    "#     result = re.sub(r' *([?!:;]) *', lambda x: ' {} '.format(x.group().strip()), result)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M. Charles Granger, hello ? Are you there ? ! ? \n"
     ]
    }
   ],
   "source": [
    "def betterSpaceCorrect(text, correspondances):\n",
    "    \"\"\"Corrects spacing in a string according to punctuation rules, with corespondances used instead of hard-coded rules.\n",
    "    \n",
    "    Args:\n",
    "        text (string): the string to correct\n",
    "        correspondances (dict): dictionary that specifies the punctuation rules.\n",
    "            Format of punctuation corresponds to [before, after]\n",
    "        \n",
    "    Returns:\n",
    "        string: the corrected string\n",
    "    \"\"\"\n",
    "    # splits the input string by spaces to separate character groups\n",
    "#     groups = text.split(' ')\n",
    "    \n",
    "    #filters out empty strings\n",
    "#     no_empty_string = list(filter(lambda x: x != '', groups))\n",
    "    \n",
    "    # iterates over each character group and transforms them to correct punctuation\n",
    "#     with_space_after = [_better_transform(x, correspondances) for x in no_empty_string]\n",
    "    \n",
    "    #joins back each character group with spaces between them\n",
    "#     joined = ' '.join(with_space_after)\n",
    "    transformed = _better_transform(text, correspondances)\n",
    "    \n",
    "    # before returning the result, we clean the string once more to fix double spacing\n",
    "    # which may be due to 2 symbols being next to each other\n",
    "    return _fix_double_space(transformed)\n",
    "\n",
    "print(betterSpaceCorrect(dirty_input, correspondances))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Q2.3. Enhance spaceCorrect to take lists into account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dirty_input_with_lists = \"\"\"M.   Charles Granger , hello?Are you there?!?\n",
    "\n",
    "- premier point ;\n",
    "- deuxième point   .\n",
    "\n",
    "- deuxième point,\n",
    "\n",
    "- dernier point   ;\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def _fix_lists(text):\n",
    "    \"\"\"substitutes string sthat match the regex pattern and invokes the lambda function to format each match object\"\"\"\n",
    "    pattern = r'\\n*(- )(.+)([.,;])'\n",
    "    formatted = re.sub(pattern, lambda x: _reformat_list(x), text )\n",
    "    return formatted\n",
    "\n",
    "def _reformat_list(list_item):\n",
    "    \"\"\"Formats the list item regex match object provided\"\"\"\n",
    "    ending_symbol = list_item.group(3)\n",
    "    \n",
    "    #replaces the ending symbol if it is not a full stop or a semi-colon\n",
    "    if not ending_symbol in ['.',';']:\n",
    "        ending_symbol = ';'\n",
    "    \n",
    "    #formats the list item nicely\n",
    "    result = '\\n{dash}{item}{end}'.format(\n",
    "        dash = list_item.group(1),\n",
    "        item = list_item.group(2).rstrip(),\n",
    "        end = ending_symbol)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M. Charles Granger, hello ? Are you there ? ! ? \n",
      "- premier point; \n",
      "- deuxième point. \n",
      "- deuxième point; \n",
      "- dernier point; \n"
     ]
    }
   ],
   "source": [
    "def enhancedSpaceCorrect(text, correspondances):\n",
    "    \"\"\"Corrects spacing in a string according to punctuation rules, also taking into account lists.\n",
    "    \n",
    "    Args:\n",
    "        text (string): the string to correct\n",
    "        correspondances (dict): dictionary that specifies the punctuation rules.\n",
    "            Format of punctuation corresponds to [before, after]\n",
    "        \n",
    "    Returns:\n",
    "        string: the corrected string\n",
    "    \"\"\"\n",
    "    # splits the input string by spaces to separate character groups\n",
    "#     groups = text.split(' ')\n",
    "    \n",
    "    #filters out empty strings\n",
    "#     no_empty_string = list(filter(lambda x: x != '', groups))\n",
    "    \n",
    "    # iterates over each character group and transforms them to correct punctuation\n",
    "#     with_space_after = [_transform(x) for x in no_empty_string]\n",
    "    \n",
    "    #joins back each character group with spaces between them\n",
    "    joined = _transform(text)\n",
    "    \n",
    "    #fix lists\n",
    "    fixed_lists = _fix_lists(joined)\n",
    "    \n",
    "    # before returning the result, we clean the string once more to fix double spacing\n",
    "    # which may be due to 2 symbols being next to each other\n",
    "    return _fix_double_space(fixed_lists)\n",
    "print(enhancedSpaceCorrect(dirty_input_with_lists, correspondances))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Front End, HTML Form operations\n",
    ">Write a Javascript (or Coffeescript) plugin which suggests to the user to choose between all \"fondateur\" persons with a click and then fill automatically the \"president\" fieldset using the \"data-from\" attribute.\n",
    "\n",
    ">Any external plugin is welcome (jQuery, Zepto, Underscore, etc.)\n",
    "\n",
    ">Here's a fiddle to help and start the work: http://jsfiddle.net/lajarre/VD3mY/4/\n",
    "\n",
    "Answer in React is here: https://jsfiddle.net/ziinc/yhz3grfd/5/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}