JSON schema.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://json-schema.org/implementations.html\n",
    "\n",
    "Pypi https://pypi.org/project/jsonschema/ currently 2.6.0\n",
    "\n",
    "Github tag 2.6.0 https://github.com/Julian/jsonschema/blob/v2.6.0/jsonschema/__init__.py\n",
    "\n",
    "Docs https://python-jsonschema.readthedocs.io/en/v2.6.0/\n",
    "\n",
    "Writing schemas:\n",
    "- https://json-schema.org/understanding-json-schema/index.html \n",
    "- https://json-schema.org/understanding-json-schema/reference/index.html\n",
    "\n",
    "Online validator (not for draft4 though) https://jsonschema.net/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import jsonschema\n",
    "assert jsonschema.__version__ == '2.6.0'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from jsonschema import validate\n",
    "from jsonschema import Draft4Validator as Validator\n",
    "from jsonschema.exceptions import (\n",
    "    RefResolutionError,\n",
    "    SchemaError,\n",
    "    UnknownType,\n",
    "    ValidationError,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A sample schema, like what we'd get from json.load()\n",
    "schema = {\n",
    "     \"type\" : \"object\",\n",
    "     \"properties\" : {\n",
    "         \"name\" : {\"type\" : \"string\"},\n",
    "         \"price\" : {\"type\" : \"number\"},\n",
    "         \"stock\" : {\"type\" : \"number\"},\n",
    "     },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "good_data = {\"name\" : \"Eggs\", \"price\" : 34.9, \"stock\": 34}\n",
    "bad_data = {\"name\": \"Eggs\", \"price\" : \"invalid as price\", \"stock\": \"invalid as stock\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://python-jsonschema.readthedocs.io/en/v2.6.0/validate/#jsonschema.validate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If no exception is raised by validate(), the instance is valid.\n",
    "try:\n",
    "    validate(good_data, schema, cls=Validator)\n",
    "except ValidationError as e:\n",
    "    print(str(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "absolute_path : deque(['stock'])\n",
      "absolute_schema_path : deque(['properties', 'stock', 'type'])\n",
      "args : (\"'invalid as stock' is not of type 'number'\", <unset>, (), None, (), <unset>, <unset>, <unset>, (), None)\n",
      "cause : None\n",
      "context : []\n",
      "create_from : <bound method type.create_from of <class 'jsonschema.exceptions.ValidationError'>>\n",
      "instance : invalid as stock\n",
      "message : 'invalid as stock' is not of type 'number'\n",
      "parent : None\n",
      "path : deque(['stock'])\n",
      "relative_path : deque(['stock'])\n",
      "relative_schema_path : deque(['properties', 'stock', 'type'])\n",
      "schema : {'type': 'number'}\n",
      "schema_path : deque(['properties', 'stock', 'type'])\n",
      "validator : type\n",
      "validator_value : number\n",
      "with_traceback : <built-in method with_traceback of ValidationError object at 0x7f4c8efdfe88>\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    validate(bad_data, schema, cls=Validator)\n",
    "except ValidationError as e:\n",
    "    for attr in sorted(dir(e)):\n",
    "        if not attr.startswith('_'):\n",
    "            print(attr, ':', getattr(e, attr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doesn't seem to report all errors in this mode...\n",
    "\n",
    "https://python-jsonschema.readthedocs.io/en/v2.6.0/errors/#handling-validation-errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'invalid as price' is not of type 'number'\n",
      "'invalid as stock' is not of type 'number'\n"
     ]
    }
   ],
   "source": [
    "v = Validator(schema)\n",
    "for error in sorted(v.iter_errors(bad_data), key=str):\n",
    "    print(error.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_schema = {\n",
    "    \"type\" : \"array\",\n",
    "    \"items\" : {\n",
    "        \"type\" : \"number\", \n",
    "        \"enum\" : [1, 2, 3]\n",
    "    },\n",
    "    \"minItems\" : 3,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'spam' is not of type 'number'\n",
      "'spam' is not one of [1, 2, 3]\n",
      "['spam', 2] is too short\n"
     ]
    }
   ],
   "source": [
    "v = Validator(array_schema)\n",
    "for error in sorted(v.iter_errors([\"spam\", 2]), key=str):\n",
    "    print(error.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'spam' is not of type 'number'\n",
      "'spam' is not one of [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "v = Validator(array_schema)\n",
    "for error in sorted(v.iter_errors([\"spam\", 2, 3]), key=str):\n",
    "    print(error.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is not one of [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "v = Validator(array_schema)\n",
    "for error in sorted(v.iter_errors([0, 2, 3]), key=str):\n",
    "    print(error.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Validator(array_schema)\n",
    "for error in sorted(v.iter_errors([1, 2, 3]), key=str):\n",
    "    print(error.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can traverse errors also using tree = ErrorTree(v.iter_errors(instance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['spam', 2] is too short\n"
     ]
    }
   ],
   "source": [
    "# best match error - select one!\n",
    "# https://python-jsonschema.readthedocs.io/en/v2.6.0/errors/#best-match-and-relevance\n",
    "from jsonschema.exceptions import best_match\n",
    "print(best_match(v.iter_errors([\"spam\", 2])).message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use with SQLA constructor?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.2.10'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sqlalchemy\n",
    "sqlalchemy.__version__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import Column, Integer, String\n",
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.orm import sessionmaker\n",
    "\n",
    "engine = create_engine('sqlite:///:memory:') #, echo=True)\n",
    "Base = declarative_base()\n",
    "\n",
    "user_schema = {\n",
    "    \"type\" : \"object\",\n",
    "    \"properties\" : {\n",
    "        \"name\" : {\n",
    "            \"type\" : \"string\", \n",
    "            \"minlength\": 1\n",
    "        },\n",
    "        \"email\" : {\n",
    "            \"type\" : \"string\",\n",
    "            \"pattern\": r\"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)\"\n",
    "        },\n",
    "    },\n",
    "    \"additionalProperties\": False,\n",
    "    \"required\": [\"name\", \"email\"],\n",
    "}\n",
    "\n",
    "class User(Base):\n",
    "    __tablename__ = 'users'  # required but assigned automatically if omitted in flask-sqlalchemy \n",
    "\n",
    "    id = Column(Integer, primary_key=True)  # at least one primary key is required \n",
    "    name = Column(String, nullable=False)\n",
    "    email = Column(String, nullable=False)\n",
    "    \n",
    "    def __init__(self, *args, **kwargs):\n",
    "        validate(kwargs, user_schema, Validator)  # intercept kwargs!\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"<User(name='%s', email='%s')>\" % (self.name, self.email)\n",
    "\n",
    "Base.metadata.create_all(engine)\n",
    "Session = sessionmaker(bind=engine)\n",
    "session = Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "user = User(name='ed', email='ed@gmail.com')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "message: Additional properties are not allowed ('other' was unexpected)\n",
      "item fails additionalProperties\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    user = User(name='ed', email='ed@gmail.com', other='foo')\n",
    "except ValidationError as e:\n",
    "    print('message:', e.message)\n",
    "    print('{0} fails {1}'.format(e.path[-1] if e.path else 'item', e.validator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "message: 'name' is a required property\n",
      "item fails required\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    user = User()\n",
    "except ValidationError as e:\n",
    "    print('message:', e.message)\n",
    "    print('{0} fails {1}'.format(e.path[-1] if e.path else 'item', e.validator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "message: 'ed@gmail@com' does not match '(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\\\.[a-zA-Z0-9-.]+$)'\n",
      "email fails pattern\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    user = User(name='ed', email='ed@gmail@com')\n",
    "except ValidationError as e:\n",
    "    print('message:', e.message)\n",
    "    print('{0} fails {1}'.format(e.path[-1] if e.path else 'item', e.validator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How to coordinate with the database?\n",
    "\n",
    "Pretty difficult. The fact that the schema itself can be traversed means that we can extract constraints on properties, but translating it to SQL check constraint would be manual, hard to see a programmable method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integrate with WTForms?\n",
    "\n",
    "Someone appears to be working on WTForms to jsonschema but 'To embed a JSON Schema as a form field' is 'TODO:':\n",
    "```\n",
    "class MyForm(forms.Form):\n",
    "    subfield = JSONSchemaField(schema=schema)\n",
    "```\n",
    "\n",
    "Bingo? https://pythonhosted.org/Flask-Inputs/#json-validation or maybe not could be that's using WTForms validators... \n",
    "\n",
    "Perhaps custom validators and pull out the relevant part of the schema https://wtforms.readthedocs.io/en/stable/validators.html#custom-validators?\n",
    "\n",
    "https://medium.com/@doobeh/posting-a-wtform-via-ajax-with-flask-b977782edeee\n",
    "\n",
    "HTTP form encoding (hence WTForms?) cannot represent nested data https://github.com/requests/requests/issues/2885 so I guess the 'API spec' for HTTPs posts has to be a simple schema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Where could hook a validation for modifying an instance?\n",
    "\n",
    "decorators https://github.com/mikefromit/flask-jsonschema-example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import event\n",
    "\n",
    "def my_name_set_listener(target, value, oldvalue, initiator):\n",
    "    print('Have received an set event for User.name', target)\n",
    "    \n",
    "event.listen(User.name, 'set', my_name_set_listener)\n",
    "\n",
    "def my_user_update_listener(mapper, connection, target):\n",
    "    print('Have received an update event for User')\n",
    "    \n",
    "event.listen(User, 'before_update', my_user_update_listener)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have received an set event for User.name <User(name='None', email='ed@gmail.com')>\n"
     ]
    }
   ],
   "source": [
    "user = User(name='ed', email='ed@gmail.com')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.add(user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.flush()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_user = session.query(User).first()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<User(name='ed', email='ed@gmail.com')>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have received an set event for User.name <User(name='ed', email='ed@gmail.com')>\n"
     ]
    }
   ],
   "source": [
    "a_user.name = 'foo'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "session.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have received an update event for User\n"
     ]
    }
   ],
   "source": [
    "a_user = session.query(User).first()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<User(name='foo', email='ed@gmail.com')>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fields that must be present on init\n",
    "# Intercept kwargs in __init__ and apply the following validator.\n",
    "user_model_instantiate_schema = {\n",
    "    \"type\" : \"object\",\n",
    "    \"properties\" : {\n",
    "        \"username\" : {\n",
    "            \"type\" : \"string\",\n",
    "            \"minlength\": 1,\n",
    "            \"maxlength\": 64,\n",
    "        },\n",
    "        \"email\" : {\n",
    "            \"type\" : \"string\",\n",
    "            \"pattern\": r\"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)\"\n",
    "        },\n",
    "        \"password\" : {\n",
    "            \"type\" : \"string\",\n",
    "            \"pattern\": r\"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)\"\n",
    "        },\n",
    "        \"about_me\" : {\n",
    "            \"type\": \"string\",\n",
    "            \"maxlength\": 140,\n",
    "        }\n",
    "    },\n",
    "    \"additionalProperties\": False,  # don't allow anything else\n",
    "    \"required\": [\"username\", \"email\", \"password\"],  # require these\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The update function is a bit more complicated.\n",
    "\n",
    "We could set listeners for attribute set events on the model\n",
    "http://docs.sqlalchemy.org/en/latest/orm/events.html#sqlalchemy.orm.events.AttributeEvents.set                              \n",
    "but that would involve setting up a listener for each field mentioned in the schema.  They could all call the same validation routine.                                                                                                                    \n",
    "                                                                                                                             \n",
    "It does not seem that there is a way to listen for a change in __any__ attribute, or any in attribute in a list.                                                                                                                                                                                                               \n",
    "\n",
    "However the update function is usually closely followed by flush so it would be simpler to have just one listener for that http://docs.sqlalchemy.org/en/latest/orm/events.html#sqlalchemy.orm.events.MapperEvents.before_update this could be put into a package level validate routine (operating on instance.to_dict, schema) method that could be triggered manually as well.                                                                                                                    \n",
    "                                                                                                                            \n",
    "But what would we pass to the jsonschema.validate method?  I guess this needs to be the serialized instance, but not of all the fields since some (password_hash) are not appropriate. Hmm. I guess the validate change needs to be applied as in the ```__init__``` e.g. ```update(self, *args, **kwargs)``` and the user should use that to make a __validated__ change. This would avoid listeners entirely, which seems like a good thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_model_update_schema = {  # password_hash is not                                                                          \n",
    "    \"type\" : \"object\",\n",
    "    \"properties\" : {\n",
    "        \"email\" : {\n",
    "            \"type\" : \"string\",\n",
    "            \"pattern\": r\"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)\"\n",
    "        },\n",
    "        \"password\" : {\n",
    "            \"type\" : \"string\",\n",
    "            \"pattern\": r\"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)\"\n",
    "        },\n",
    "        \"about_me\" : {\n",
    "            \"type\": \"string\",\n",
    "            \"maxlength\": 140,\n",
    "        },\n",
    "        \"last_seen\" : {\n",
    "            \"type\": \"string\",\n",
    "            # matches a datetime pattern                                                                                      \n",
    "        },\n",
    "        \"token\": {\n",
    "            \"type\": \"string\",\n",
    "            # matches some encoded length datetime pattern                                                                    \n",
    "        },\n",
    "        \"token_expiration\" : {\n",
    "            \"type\": \"string\",\n",
    "            # matches a datetime pattern                                                                                      \n",
    "        },\n",
    "    },\n",
    "    \"additionalProperties\": False,\n",
    "    \"required\": [\"username\"],\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually all this overlooks quite a bit problem which is that jsonschema validates json so anything non-json-serializable like a date cannot be passed to a class..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "datetime.datetime(2018, 8, 13, 11, 41, 52, 178180) is not of type 'string'\n",
      "\n",
      "Failed validating 'type' in schema['properties']['date']:\n",
      "    {'type': 'string'}\n",
      "\n",
      "On instance['date']:\n",
      "    datetime.datetime(2018, 8, 13, 11, 41, 52, 178180)\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime, timezone\n",
    "# A sample schema, like what we'd get from json.load()\n",
    "date_schema = {\n",
    "     \"type\" : \"object\",\n",
    "     \"properties\" : {\n",
    "         \"date\" : {\"type\" : \"string\"},\n",
    "     },\n",
    "}\n",
    "data = {\n",
    "    'date': datetime.utcnow()\n",
    "}\n",
    "try:\n",
    "    validate(data, date_schema, cls=Validator)\n",
    "except ValidationError as e:\n",
    "    print(str(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seems jsonschema can be asked to support additional types but this is limited to types that can be mapped to JSON easily e.g. integer, float -> \"number\" https://python-jsonschema.readthedocs.io/en/v2.6.0/validate/#validating-types "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, datetime is maybe the most problematic one. At the end of the day all the SQLA models represent things that go into a database so all the scalar items need to be basic, if not primitive string, number etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Working with JSON in python https://realpython.com/python-json/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "class MyEncoder(json.JSONEncoder):\n",
    "    def default(self, z):\n",
    "        if isinstance(z, datetime):\n",
    "            return z.replace(tzinfo=timezone.utc).isoformat()\n",
    "        else:\n",
    "            super().default(self, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'date': '2018-08-13T12:38:54.072321+00:00', 'email': 'joegmail.com'}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# then\n",
    "json.loads(json.dumps(data, cls=MyEncoder))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'date': '2018-08-13T11:41:39.659715+00:00'}\n"
     ]
    }
   ],
   "source": [
    "# and works\n",
    "date_schema = {\n",
    "     \"type\" : \"object\",\n",
    "     \"properties\" : {\n",
    "         \"date\" : {\n",
    "             \"type\" : \"string\",\n",
    "             \"pattern\": r\"^\\d{4}-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\d\\.\\d{6}[+-]\\d\\d:\\d\\d$\"\n",
    "         },\n",
    "     },\n",
    "}\n",
    "data = {\n",
    "    'date': datetime.utcnow()\n",
    "}\n",
    "serializable_data = json.loads(json.dumps(data, cls=MyEncoder))\n",
    "print(serializable_data)\n",
    "try:\n",
    "    validate(serializable_data, date_schema, cls=Validator)\n",
    "except ValidateError as e:\n",
    "    print(str(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'email': 'joegmail.com', 'date': '2018-08-13T11:41:19.787115+00:00'}\n",
      "'joegmail.com' is not a 'email'\n",
      "\n",
      "Failed validating 'format' in schema['properties']['email']:\n",
      "    {'format': 'email', 'type': 'string'}\n",
      "\n",
      "On instance['email']:\n",
      "    'joegmail.com'\n"
     ]
    }
   ],
   "source": [
    "# or there is a cool format defined here\n",
    "# https://json-schema.org/understanding-json-schema/reference/string.html#format\n",
    "# BUT see warning\n",
    "from jsonschema import FormatChecker\n",
    "date_schema = {\n",
    "     \"type\" : \"object\",\n",
    "     \"properties\" : {\n",
    "         \"date\" : {\n",
    "             \"type\" : \"string\",\n",
    "             \"format\": \"date-time\"\n",
    "         },\n",
    "         \"email\" : {\n",
    "             \"type\" : \"string\",\n",
    "             \"format\": \"email\"\n",
    "         },\n",
    "     },\n",
    "}\n",
    "data = {\n",
    "    'date': datetime.utcnow(),\n",
    "    'email': 'joegmail.com'\n",
    "}\n",
    "serializable_data = json.loads(json.dumps(data, cls=MyEncoder))\n",
    "print(serializable_data)\n",
    "try:\n",
    "    validate(serializable_data, date_schema, cls=Validator,\n",
    "            format_checker=FormatChecker())  # warning MUST specify this or will pass silently\n",
    "except ValidationError as e:\n",
    "    print(str(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Also, point here would be to ensure a standard format throughout the app\n",
    "# not necessarily the one decided by JSON or jsonschema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.4.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}