testing_ch35t.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Ch35t client\n",
    "\n",
    "My client for the Ch35t format is still at an early stage, but it already\n",
    "implements some basic features including loading/parsing chest files and\n",
    "dealing with different types of data both for the hint and for the payload.\n",
    "\n",
    "## Parser\n",
    "\n",
    "The parser takes care of, well... parsing :-) the JSON files describing chests.\n",
    "It provides methods to manually parse JSONs from URLs, files, or strings, \n",
    "however these methods are mostly used internally as the constructor tries\n",
    "to automatically detect what it is dealing with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "import parser\n",
    "\n",
    "# if a Parser is instantiated with no input params, it\n",
    "# will have an empty json\n",
    "cp = parser.Parser()\n",
    "print(cp.json())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manually load a chest\n",
    "### From file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label': {'name': 'I am a dummy chest',\n",
       "  'URI': 'http://3564030356.org/ch35t/examples/dummy.json',\n",
       "  'author': 'mala@sdf.org'},\n",
       " 'hint': {'origin': 'http://this.is.the/hint/origin',\n",
       "  'data': 'This is the hint data.',\n",
       "  'format': 'text/plain'},\n",
       " 'payload': {'data': 'This is simple, unuseful, plain text payload data.',\n",
       "  'format': 'text/plain'}}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cp._load_file(\"examples/dummy.json\")\n",
    "cp.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From URL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = \"http://3564020356.org/ch35t/examples/dummy.json\"\n",
    "cp._load_url(url)\n",
    "cp.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label': {'name': 'I am a dummy chest',\n",
       "  'URI': 'http://3564030356.org/ch35t/examples/dummy.json',\n",
       "  'author': 'mala@sdf.org'},\n",
       " 'hint': {'origin': 'http://this.is.the/hint/origin',\n",
       "  'data': 'This is the hint data.',\n",
       "  'format': 'text/plain'},\n",
       " 'payload': {'data': 'This is simple, unuseful, plain text payload data.',\n",
       "  'format': 'text/plain'}}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jj = '''\n",
    "{\n",
    "  \"label\": {\n",
    "    \"name\": \"I am a dummy chest\",\n",
    "    \"URI\": \"http://3564030356.org/ch35t/examples/dummy.json\",\n",
    "    \"author\": \"mala@sdf.org\"\n",
    "  },\n",
    "  \"hint\": {\n",
    "    \"origin\": \"http://this.is.the/hint/origin\",\n",
    "    \"data\": \"This is the hint data.\",\n",
    "    \"format\": \"text/plain\"\n",
    "  },\n",
    "  \"payload\": {\n",
    "    \"data\": \"This is simple, unuseful, plain text payload data.\",\n",
    "    \"format\": \"text/plain\"\n",
    "  }\n",
    "}'''\n",
    "cp._load_string(jj)\n",
    "cp.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*NOTE* that manual load won't probably be required."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load automatically\n",
    "Parser is able to automatically detect whether the JSON chest description is being passed as an URL, a file, or a string. If it is initalised\n",
    "with a string that starts with `http://` or `https://` it will automatically\n",
    "call load_url, if it starts with `file://` it will automatically load a file,\n",
    "otherwise it will load a string.\n",
    "As we might want a URL to be considered as a string and not as a reference to\n",
    "some content, it is still possible to do that by instantiating an emtpy parser\n",
    "and loading the url as a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label': {'name': 'I am a dummy chest',\n",
       "  'URI': 'http://3564030356.org/ch35t/examples/dummy.json',\n",
       "  'author': 'mala@sdf.org'},\n",
       " 'hint': {'origin': 'http://this.is.the/hint/origin',\n",
       "  'data': 'This is the hint data.',\n",
       "  'format': 'text/plain'},\n",
       " 'payload': {'data': 'This is simple, unuseful, plain text payload data.',\n",
       "  'format': 'text/plain'}}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cp = parser.Parser(jj)\n",
    "cp.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'hint': {'data': 'this is the hint', 'format': 'text/plain'},\n",
       " 'payload': {'data': 'this is the payload',\n",
       "  'format': 'text/plain',\n",
       "  'method': 'No method'}}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cp = parser.Parser(\"http://3564020356.org/ch35t/examples/dummy.json\")\n",
    "cp.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label': {'name': 'I am a dummy chest',\n",
       "  'URI': 'http://3564030356.org/ch35t/examples/dummy.json',\n",
       "  'author': 'mala@sdf.org'},\n",
       " 'hint': {'origin': 'http://this.is.the/hint/origin',\n",
       "  'data': 'This is the hint data.',\n",
       "  'format': 'text/plain'},\n",
       " 'payload': {'data': 'This is simple, unuseful, plain text payload data.',\n",
       "  'format': 'text/plain'}}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cp = parser.Parser(\"file://examples/dummy.json\")\n",
    "cp.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dump hint and payload contents\n",
    "\n",
    "Hint and payload can be *printed* and can be *dumped*. If one explicitly calls their *dump* methods, a dump of their content (not the raw json, but not the handled content yet) is returned.\n",
    "\n",
    "To actually *print* them (via their `__str__` method) we will need to additional set a context for the respective objects. This provides extra info required for proper handling of the payloads (right now, just an `output_dir` field specifying where chest data will be stored)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[i] Hint\n",
      "    Origin: http://this.is.the/hint/origin\n",
      "    Data: This is the hint data.\n",
      "    Format: text/plain\n",
      "\n",
      "[i] Payload\n",
      "    Origin: None\n",
      "    Data: This is simple, unuseful, plain text payload data.\n",
      "    Format: text/plain\n",
      "    Method: None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# dump can be run without setting context\n",
    "print(cp.hint().dump())\n",
    "print(cp.payload().dump())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build hint object\n",
    "\n",
    "Every hint is characterised by some `data` content and a `format`. Depending on the format, the hint will be interpreted in different ways (see e.g. https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types):\n",
    "\n",
    "* `text/plain`: data can be simply printed\n",
    "* `text/html`: html that needs to be interpreted/shown properly\n",
    "* `image/*`: data will be displayed by the appropriate application\n",
    "* `application/zip`: a zip file, to be unpacked in the chest directory\n",
    "* `application/octet-stream`: this is a generic file (perhaps one wants to make the hint a riddle too?)\n",
    "\n",
    "NOTE that if we want to have BOTH online and offline stuff, we could have an `origin` for URL origins, `format` for their remote formats, `data` for the actual data that is downloaded from the URL and base64-encoded to allow for offline access.\n",
    "\n",
    "SO:\n",
    "* the fields under `hint` are `origin`, `format`, and `data`\n",
    "* if we want to specify a hint by reference we provide `origin` (any URL) and `format` (the format of the data that will be returned by that URL, if the app has to parse it)\n",
    "* if we want to specify a hint by value we provide `data` in a way that recalls [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs), i.e. as in\n",
    "```\n",
    "data:[<mediatype>][;base64],<data>\n",
    "```\n",
    "* `mediatype` is specified as `format` and if `origin` and `data` are both present they share the same mediatype. Also format is, by default, `text/plain`\n",
    "* `base64` is provided at the beginning of `data` if we want the data to be provided as encoded (great if we have binaries)\n",
    "* `data` is the actual data. Differently from data URLs, it is NOT provided as URI-encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From this json:\n",
      "{'hint': {'origin': 'http://3564020356.org/deserve.htm', 'data': 'base64,TUFMIFRJUlJVRVpGIENSIE1BTCBSS1pZSU9MIEVYIE1BTCBPSVkgVUFFIFJJQ0YgIk1BTCBBQ1dBTFJNIERZRVVQTEZXTCBDUiBNRSBEWUVVIE1BSU0gVUwgSVpMIFJLWlpFS1lGTEYgR0ggT0hSTUxaSCI='}}\n",
      "\n",
      "... We get the following hint:\n",
      "MAL TIRRUEZF CR MAL RKZYIOL EX MAL OIY UAE RICF \"MAL ACWALRM DYEUPLFWL CR ME DYEU MAIM UL IZL RKZZEKYFLF GH OHRMLZH\"\n"
     ]
    }
   ],
   "source": [
    "import hint as h\n",
    "\n",
    "jj = '''{\n",
    "\"hint\": { \n",
    "  \"origin\": \"http://3564020356.org/deserve.htm\",\n",
    "  \"data\": \"base64,TUFMIFRJUlJVRVpGIENSIE1BTCBSS1pZSU9MIEVYIE1BTCBPSVkgVUFFIFJJQ0YgIk1BTCBBQ1dBTFJNIERZRVVQTEZXTCBDUiBNRSBEWUVVIE1BSU0gVUwgSVpMIFJLWlpFS1lGTEYgR0ggT0hSTUxaSCI=\" \n",
    "}}'''\n",
    "\n",
    "context = { \"output_dir\": \"/tmp/chests\" }\n",
    "cp._load_string(jj)\n",
    "print(f\"From this json:\\n{cp.json()}\")\n",
    "hint = h.Hint(cp.json())\n",
    "hint.set_ctx(context)\n",
    "print(f\"\\n... We get the following hint:\\n{hint}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build payload\n",
    "\n",
    "Note that at the moment we do not have a `toString` implementation for payloads yet, so printing them will just return the object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<payload.Payload object at 0x12d14fe50>\n"
     ]
    }
   ],
   "source": [
    "import payload as p\n",
    "\n",
    "jj = '''{\n",
    "\"payload\": { \n",
    "  \"data\": \"this is the payload\"\n",
    "}\n",
    "}'''\n",
    "\n",
    "cp._load_string(jj)\n",
    "cp.json()\n",
    "payload = p.Payload(cp.json())\n",
    "print(payload)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Playing Ch35t\n",
    "\n",
    "Rather than providing a client to play with chests, I am trying to build\n",
    "primitives that can be used by them to do so. All of this is to say, for\n",
    "now there are only two ways to play:\n",
    "\n",
    "* through these notebook cells :-)\n",
    "* using the CLI tool (ie. running `python cli.py` from a terminal)\n",
    "\n",
    "The `ch35t.Chest` class is initialised with a chest (file, URL, or string)\n",
    "and then allows you to show the chest's hint and unlock the chest.\n",
    "Depending on the format of the hint and the payload, different actions\n",
    "are taken.\n",
    "\n",
    "## Deserve\n",
    "\n",
    "The example below loads a very simple chest, which provides the hint as\n",
    "plain text and has no real contents, just a password (the key) which is\n",
    "encrypted using MD5 and that you need to guess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You found a chest named 'Deserve Me'.\n",
      "It carries a hint for its unlocking:\n",
      "MAL TIRRUEZF CR MAL RKZYIOL EX MAL OIY UAE RICF \"MAL ACWALRM DYEUPLFWL CR ME DYEU MAIM UL IZL RKZZEKYFLF GH OHRMLZH\"\n"
     ]
    }
   ],
   "source": [
    "from ch35t import Chest\n",
    "\n",
    "def show_hint(chest):\n",
    "    print(f\"You found a chest named '{chest.name()}'.\")\n",
    "    print(f\"It carries a hint for its unlocking:\\n{chest.hint}\")\n",
    "\n",
    "c = Chest(\"file://examples/deserve.json\", chests_dir=\"./chests\")\n",
    "show_hint(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... Note that if you do not want to immediately show the hint's data in the JSON file you can provide it as base64-encoded, as in the following example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You found a chest named 'Deserve Me - A base64 variant'.\n",
      "It carries a hint for its unlocking:\n",
      "MAL TIRRUEZF CR MAL RKZYIOL EX MAL OIY UAE RICF \"MAL ACWALRM DYEUPLFWL CR ME DYEU MAIM UL IZL RKZZEKYFLF GH OHRMLZH\"\n"
     ]
    }
   ],
   "source": [
    "c = Chest(\"file://examples/deserve_b64.json\", chests_dir=\"./chests\")\n",
    "show_hint(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... now it's your turn to provide the key to open the chest!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the key to unlock this chest:Whatever\n",
      "The key is not correct. The chest is still locked.\n"
     ]
    }
   ],
   "source": [
    "def unlock_chest(chest):\n",
    "    key = input(\"Enter the key to unlock this chest:\")\n",
    "    if (chest.unlock(key)):\n",
    "        print(\"Yay, you provided the right key and unlocked the chest!\")\n",
    "    else:\n",
    "        print(\"The key is not correct. The chest is still locked.\")\n",
    "        \n",
    "unlock_chest(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Riddle 02\n",
    "\n",
    "The following example has a similar payload, i.e. a MD5-encrypted password\n",
    "that has to be guessed. However, the hint is a bit more complicated: its data\n",
    "is provided as a zip file, so the `show_hint` method will take care of\n",
    "unpacking it and showing you its contents. You will then need to go to the\n",
    "hint's directory and study the hint (this one is already quite harder than\n",
    "the previous one!) before you try guessing the key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You found a chest named 'riddle02'.\n",
      "It carries a hint for its unlocking:\n",
      "Files are available in ./chests:\n",
      "riddle02/\n",
      "riddle02/+Ma's Reversing Riddle 02_files/\n",
      "riddle02/+Ma's Reversing Riddle 02_files/0c.zip\n",
      "riddle02/+Ma's Reversing Riddle 02_files/alice.gif\n",
      "riddle02/+Ma's Reversing Riddle 02_files/skull02.jpg\n",
      "riddle02/+Ma's Reversing Riddle 02.html\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from ch35t import Chest\n",
    "\n",
    "c = Chest(\"file://examples/riddle02.json\", chests_dir=\"./chests\")\n",
    "show_hint(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the key to unlock this chest:Whatever\n",
      "The key is not correct. The chest is still locked.\n"
     ]
    }
   ],
   "source": [
    "unlock_chest(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hic Sunt Leones\n",
    "\n",
    "This section is unexplored territory! Here I am just playing with different\n",
    "libraries to test new functionalities (I'll remove it if this bothers you\n",
    "but I thought it would have been a nice peek into what I am playing with...)\n",
    "\n",
    "## Chest signatures\n",
    "\n",
    "Testing which libs to use to enable chest signing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.primitives import hashes\n",
    "from cryptography.hazmat.primitives.asymmetric import rsa, padding\n",
    "\n",
    "private_key = rsa.generate_private_key(\n",
    "    public_exponent=65537,\n",
    "    key_size=2048,\n",
    ")\n",
    "public_key = private_key.public_key()\n",
    "pad = padding.PSS(\n",
    "    mgf=padding.MGF1(hashes.SHA256()),\n",
    "    salt_length=padding.PSS.MAX_LENGTH\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = b\"A message I want to sign\"\n",
    "bad_message = b\"A message different from the one I signed\"\n",
    "\n",
    "signature = private_key.sign(\n",
    "    message,\n",
    "    pad,\n",
    "    hashes.SHA256()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'A message I want to sign': good messaage\n",
      "b'A message different from the one I signed': bad message\n"
     ]
    }
   ],
   "source": [
    "for m in [message, bad_message]:\n",
    "    try:\n",
    "        public_key.verify(\n",
    "            signature,\n",
    "            m,\n",
    "            pad,\n",
    "            hashes.SHA256()\n",
    "        )\n",
    "        print(f\"{m}: good messaage\")\n",
    "    except Exception as e:\n",
    "        print(f\"{m}: bad message\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symmetric Encryption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "from methodhandlers import AESHandler\n",
    "\n",
    "with open(\"riddle02.wip/riddle02b.enc\", \"rt\") as f:\n",
    "    rid = f.read()\n",
    "\n",
    "ctx = {}\n",
    "ctx['output_dir'] = \"/tmp/chests\"\n",
    "h = AESHandler(f\"base64,{rid}         \", ctx)\n",
    "# len(f\"base64,{rid}         \")/16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "ct = h.lock(\"secret\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = AESHandler(ct, ctx)\n",
    "h.unlock(\"secret\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import methodhandlers\n",
    "import parser \n",
    "\n",
    "cp = parser.Parser(\"file://examples/deserve_aes.json\")\n",
    "h = methodhandlers.get_handler(\"AES\", cp.payload().data, ctx)\n",
    "h.unlock(\"secret\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5ebe2294ecd0e0f08eab7690d2a6ee69'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from methodhandlers import MD5Handler\n",
    "\n",
    "h = MD5Handler(\"secret\", ctx)\n",
    "h.lock()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playing with schemas\n",
    "\n",
    "In the following cells I am playing with `jsonschema` to automatically\n",
    "validate my example json files. I then extend the check so it runs as\n",
    "a unit test (will provide more broken jsons in `tests/bad_json` in the \n",
    "future). This should ideally allow anyone to work on extensions of the\n",
    "schema without breaking the client wrt existing JSON files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import fastjsonschema\n",
    "from jsonschema import validate, ValidationError\n",
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation successful\n"
     ]
    }
   ],
   "source": [
    "with open(\"schema/1.0.0.json\", \"rt\") as f:\n",
    "    s = json.load(f)\n",
    "# print(schema)\n",
    "\n",
    "with open(\"examples/deserve_b64.json\", \"rt\") as f:\n",
    "    riddle = json.load(f)\n",
    "\n",
    "try:\n",
    "    validate(schema=s, instance=riddle)\n",
    "    print(\"Validation successful\")\n",
    "except ValidationError as e:\n",
    "    print(e.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_bad_jsons (tests.validation.TestSchema) ... ok\n",
      "test_good_jsons (tests.validation.TestSchema) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 2 tests in 0.055s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x12d18b910>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "from tests.validation import TestSchema\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatically generate schema documentation\n",
    "\n",
    "aaand here's how the `schema.md` file is generated :-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Ch35t Schema\n",
      "\n",
      "*Chests as defined in the Ch35t format*\n",
      "\n",
      "## Properties\n",
      "\n",
      "- **`label`** *(object)*: A label attached to the chest, containing information about it. Cannot contain additional properties.\n",
      "  - **`name`** *(string, required)*: The chest name.\n",
      "  - **`URI`** *(string, format: uri)*: A Uniform Resource Identifier for the chest (can match the URL it can be downloaded from.\n",
      "  - **`author`** *(string, format: email)*: The email address of the chest creator (often used in conjuction with a signature.\n",
      "- **`hint`** *(object)*: A hint that might help you find the key to open the chest. Cannot contain additional properties.\n",
      "  - **`origin`** *(string, format: uri)*: A Uniform Resource Identifier for the hint (can match the URL it can be downloaded from).\n",
      "  - **`data`** *(string)*: The hint contents (plain text or base64-encoded binary).\n",
      "  - **`format`**: The format (mime-type) of the hint contents. Note that we currently allow only formats for which we have a handler, but this is not strictly necessary (i.e. we can just save files we do not know how to handle and allow players to deal with them). Must be one of: `[\"text/plain\", \"application/zip\"]`.\n",
      "- **`payload`** *(object)*: Cannot contain additional properties.\n",
      "  - **`origin`** *(string, format: uri)*: A Uniform Resource Identifier for the payload (can match the URL it can be downloaded from).\n",
      "  - **`data`** *(string)*: The hint contents (plain text or base64-encoded binary).\n",
      "  - **`format`**: The format (mime-type) of the payload contents. Note that we currently allow only formats for which we have a handler, but this is not strictly necessary (i.e. we can just save files we do not know how to handle and allow players to deal with them). Must be one of: `[\"text/plain\", \"application/zip\"]`.\n",
      "  - **`output-format`** *(string)*: The format (mime-type) of the decrypted payload. Note that as we do not necessarily need to handle this, we leave the possibility of using any format here.\n",
      "  - **`method`** *(object)*: The encryption method used to conceal the payload. Cannot contain additional properties.\n",
      "    - **`name`** *(string, required)*: The name of the encryption method.\n",
      "    - **`args`** *(array)*: Extra arguments to be provided to the method handler.\n",
      "      - **Items** *(string)*\n",
      "- **`signature`** *(string)*\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import jsonschema2md\n",
    "\n",
    "parser = jsonschema2md.Parser(\n",
    "    examples_as_yaml=False,\n",
    "    show_examples=\"all\",\n",
    ")\n",
    "with open(\"./schema/1.0.0.json\", \"r\") as json_file:\n",
    "    md_lines = parser.parse_schema(json.load(json_file))\n",
    "print(''.join(md_lines))\n",
    "\n",
    "with open (\"schema.md\", \"w\") as f:\n",
    "    f.write(''.join(md_lines))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": 4
}