notebooks/bfut_FceConverter.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# bfut_FceConverter\n",
    "\n",
    "```py \n",
    "# Author: bfut <https://github.com/bfut> (zlib License)\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Description\n",
    "\n",
    "This notebook is a step-by-step converter for FCE files between FCE3, FCE4, and FCE4M formats.\n",
    "\n",
    "Handles renaming parts, merging parts, reordering parts, renaming dummies, scaling model size, etc., where applicable.\n",
    "\n",
    "Also converts texture alpha channel. For FCE3 and FCE4, the source is a TGA file. For FCE4M, the source is an FSH file.\n",
    "\n",
    "Conversion flows:\n",
    "```\n",
    "    FCE4M -> FCE4 -> FCE3\n",
    "    FCE3  -> FCE4 -> FCE4M\n",
    "```\n",
    "Automatically determines the input file format. The target format is set as a parameter. See *Parameterize Notebook* for the how-to.\n",
    "\n",
    "# Purpose\n",
    "\n",
    "This notebook can produce a game-ready and finished VIV archive in seconds, avoiding manual chores.\n",
    "\n",
    "Preview and prepare your work for multiple games simultaneously.\n",
    "\n",
    "# Required tools\n",
    "\n",
    "1. `Python 3.10 or later`: Windows or Linux.\n",
    "\n",
    "1. Run from the command-line\n",
    "    ```sh\n",
    "    python -m pip install -U pip ipykernel\n",
    "    ```\n",
    "\n",
    "1. `fcecodec`: https://github.com/bfut/fcecodec (install Python module)\n",
    "\n",
    "1. `unvivtool`: https://github.com/bfut/unvivtool (install Python module)\n",
    "\n",
    "1. Download https://github.com/bfut/PyScripts for\n",
    "\n",
    "    * `bfut_NfsTgaConverter`\n",
    "\n",
    "    * `bfut_TextureRotator`\n",
    "\n",
    "    * `bfut_Tga2Bmp`\n",
    "\n",
    "1. `ImageMagick`: https://imagemagick.org/script/download.php (install executable) *Note:* only required when working with FSH files\n",
    "\n",
    "1. `fshtool`: https://github.com/bfut/fshtool/releases (executable)  *Note:* only required when working with FSH files\n",
    "    ```sh\n",
    "    # Windows users: extract 'fshtool_noprompt.exe'\n",
    "    # WSL/Linux users: extract 'fshtool.c' and run from the command-line\n",
    "    gcc -std=c89 -O0 path/to/fshtool.c -o fshtool_noprompt\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cpde cell is for downloading the necessary files for the notebook to work.<br>\n",
    "\n",
    "It is not required if you downloaded the notebook as part of the fcecodec_scripts release.<br>\n",
    "It is useful, if you have only the notebook, (e.g. on Google Colab).<br>\n",
    "\n",
    "It will download the following files<br>\n",
    "  * bfut_PyScripts\n",
    "  * unvivtool Python script\n",
    "  * fshtool v1.22 no user prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "# import pathlib\n",
    "# import shutil\n",
    "# import urllib\n",
    "# import zipfile\n",
    "\n",
    "# def download_file(url, output_filename):\n",
    "#     with urllib.request.urlopen(url) as response, open(output_filename, 'wb') as f:\n",
    "#         shutil.copyfileobj(response, f)\n",
    "#     return output_filename\n",
    "\n",
    "# print(pathlib.Path.cwd())\n",
    "\n",
    "# # Create utils directory\n",
    "# utils_dir = pathlib.Path(\"./utils\")\n",
    "# os.mkdir(utils_dir)\n",
    "\n",
    "# # Download bfut_PyScripts\n",
    "# os.system(f\"git clone https://github.com/bfut/PyScripts.git {utils_dir / 'bfut_PyScripts'}\")\n",
    "\n",
    "# # Download unvivtool Python script\n",
    "# my_url = \"https://raw.githubusercontent.com/bfut/unvivtool/main/scripts/unvivtool_script.py\"\n",
    "# output_filename = pathlib.Path(urllib.parse.urlparse(my_url).path).name\n",
    "# print(download_file(my_url, utils_dir / output_filename))\n",
    "\n",
    "# # Download fshtool v1.22 no user prompt\n",
    "# my_url = \"https://github.com/bfut/fshtool/releases/download/1.22%2B/fshtool_noprompt.zip\"\n",
    "# output_filename = pathlib.Path(pathlib.Path(urllib.parse.urlparse(my_url).path).name)\n",
    "# print(download_file(my_url, utils_dir / output_filename))\n",
    "# with zipfile.ZipFile(utils_dir / output_filename, 'r') as zip_ref:\n",
    "#     zip_ref.extractall(utils_dir / output_filename.stem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install required packages\n",
    "!python -m pip install -U fcecodec\n",
    "!python -m pip install -U unvivtool\n",
    "\n",
    "# Compile fshtool v1.22 no user prompt if on Linux\n",
    "import platform\n",
    "if platform.system() in [\"Linux\", \"Darwin\"]:\n",
    "    pass\n",
    "    !gcc -std=c89 -O0 utils/fshtool_noprompt/fshtool.c -o utils/fshtool_noprompt/fshtool_noprompt -w\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Workload\n",
    "\n",
    "### Parameterize Notebook\n",
    "\n",
    "1. `fce_version_target` determines the output FCE format. Set to `3`, `4` or `5` for FCE3, FCE4, or FCE4M, respectively.\n",
    "\n",
    "Files\n",
    "1. `fce_path_input` path to the source FCE file (can be FCE3, FCE4, or FCE4M)\n",
    "1. `fce_path_output` will be path to the output FCE file\n",
    "1. `fsh_path_input` path to an optional source texture in FSH format. Only used, when source file is in FCE4M format.\n",
    "1. `car00tga_input` path to an optional source texture in TGA format. Only used, when source file is not in FCE4M format.\n",
    "1. `viv_target_dir` path to the directory whose files will be encoded to the finished VIV archive. Output FCE and texture file should be written to this directory.\n",
    "1. `fce_path_colorsource` path to an optional source FCE file whose colors will be copied to the output FCE file, if desired.\n",
    "\n",
    "Misc\n",
    "1. `fce_copy_color` copy colors from another FCE file (`True` or `False`)\n",
    "1. `texture_flip_vertically` sometimes a texture has to be flipped vertically (`True` or `False`)\n",
    "\n",
    "When target version is FCE3:\n",
    "1. `convertible_fce3` if True, merge convertible top to body, if False, delete top (:OT) (`True` or `False`)\n",
    "1. `transparent_windows_fce3` if False, delete interior and high body window triangles are not semi-transparent (`True` or `False`)\n",
    "1. `rescale_factor_fce3` rescale model size (and dummy positions) by this floating point factor; 1.1 to 1.2 give good results for vanilla FCE4 models\n",
    "\n",
    "When target version is FCE4M:\n",
    "1. `fce_path_4Mpartorder_source` path to an optional source FCE4M file whose partnames and partsorder will be mimicked, if desired\n",
    "\n",
    "When source version is FCE4M:\n",
    "1. `chopped_roof_fce4m` normal or chopped roof (`True` or `False`)\n",
    "1. `convertible_fce4m` rename convertible top to :OT; overrides chopped_roof_fce4m option (`True` or `False`)\n",
    "1. `hood_scoop_fce4m` select hood scoop size (`None` or `\"small\"` or `\"big\"`)\n",
    "1. `pp_wheels_as_wheels_fce4m` rename dummy wheel parts to legitimate wheels (`True` or `False`)\n",
    "\n",
    "Tools\n",
    "1. `py_scriptsdir` path to a local copy of the `bfut/PyScripts` repository\n",
    "1. `fcecodec_scriptsdir` path to a local copy of the scripts directory of the `bfut/fcecodec` repository\n",
    "1. `fshtool_noprompt_exe` path to an `fshtool_noprompt` executable\n",
    "1. `unvivtool_script` path to a local copy of `unvivtool_script.py` from the `bfut/unvivtool` repository"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pathlib\n",
    "import platform\n",
    "\n",
    "import fcecodec as fc\n",
    "\n",
    "fce_version_target = 3\n",
    "\n",
    "# Files\n",
    "fce_path_input = \"part.fce\"\n",
    "fce_path_output = \"car.fce\"\n",
    "fsh_path_input = \"part.fsh\"\n",
    "car00tga_input = \"car00.tga\"\n",
    "car00tga_output = \"another/car00.tga\"\n",
    "viv_target_dir = \"path/to/car_viv\"\n",
    "fce_path_colorsource = \"another/car.fce\"\n",
    "\n",
    "# Misc\n",
    "fce_copy_color = False\n",
    "texture_flip_vertically = True\n",
    "\n",
    "\n",
    "# FCE3 target\n",
    "convertible_fce3 = True\n",
    "transparent_windows_fce3 = True\n",
    "rescale_factor_fce3 = 1.0\n",
    "\n",
    "\n",
    "# FCE4M target\n",
    "fce_path_4Mpartorder_source = \"path/to/some/part.fce\"\n",
    "\n",
    "\n",
    "# FCE4M source\n",
    "chopped_roof_fce4m = False\n",
    "convertible_fce4m = False\n",
    "hood_scoop_fce4m = None\n",
    "pp_wheels_as_wheels_fce4m = True\n",
    "\n",
    "\n",
    "# Paths to utils\n",
    "py_scriptsdir = \"utils/PyScripts\"\n",
    "fcecodec_scriptsdir = \"scripts\"\n",
    "fshtool_noprompt_exe = \"utils/fshtool_noprompt/fshtool_noprompt\"\n",
    "unvivtool_script = \"utils/unvivtool_script.py\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We're set. Run All."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if str(fce_version_target).lower() == \"4m\":\n",
    "    fce_version_target = 5\n",
    "fce_version_target = int(fce_version_target)\n",
    "assert fce_version_target in [3, 4, 5]\n",
    "\n",
    "py_scriptsdir = pathlib.Path(py_scriptsdir)\n",
    "fcecodec_scriptsdir = pathlib.Path(fcecodec_scriptsdir)\n",
    "fshtool_noprompt_exe = pathlib.Path(fshtool_noprompt_exe)\n",
    "unvivtool_script = pathlib.Path(unvivtool_script)\n",
    "\n",
    "# 'fce_path_input' is original file and will not be changed\n",
    "# 'fce_path_current' is variable stand-in for input path in script calls\n",
    "# 'fce_path_output' is path to output file\n",
    "fce_path_current = fce_path_input\n",
    "\n",
    "def GetFceVersion(path):\n",
    "    with open(path, \"rb\") as f:\n",
    "        version = fc.GetFceVersion(f.read(0x2038))\n",
    "        assert version > 0\n",
    "        return version\n",
    "\n",
    "input_fce_version = GetFceVersion(fce_path_current)\n",
    "print(f\"convert {input_fce_version} -> {fce_version_target}\")\n",
    "\n",
    "# Transform parameters\n",
    "param_translator = {\n",
    "    None: 0,\n",
    "    False: 0,\n",
    "    True: 1,\n",
    "    \"small\": 1,\n",
    "    \"big\": 2,\n",
    "    2: 2,\n",
    "}\n",
    "convertible_fce3 = param_translator[convertible_fce3]\n",
    "transparent_windows_fce3 = param_translator[transparent_windows_fce3]\n",
    "chopped_roof_fce4m = param_translator[chopped_roof_fce4m]\n",
    "convertible_fce4m = param_translator[convertible_fce4m]\n",
    "hood_scoop_fce4m = param_translator[hood_scoop_fce4m]\n",
    "\n",
    "rescale_factor_fce3 = float(rescale_factor_fce3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert from FCE4M to FCE4, if applicable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_fce_version = GetFceVersion(fce_path_current)\n",
    "if current_fce_version == 5 and fce_version_target < 5:\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_PrintFceInfo.py'}\" \"{fce_path_current}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_MergeParts (FceM to Fce4, keep version).py'}\" \"{chopped_roof_fce4m}\" \"{convertible_fce4m}\" \"{hood_scoop_fce4m}\" \"{fce_path_current}\" \"{fce_path_output}\"\n",
    "    if pp_wheels_as_wheels_fce4m:\n",
    "        mesh = fc.Mesh()\n",
    "        with open(fce_path_current, \"rb\") as f:\n",
    "            mesh.IoDecode(f.read())\n",
    "        assert mesh.MValid() is True\n",
    "        rename_map = {\n",
    "            \":PPLFwheel\": \":HLFW\",\n",
    "            \":PPRFwheel\": \":HRFW\",\n",
    "            \":PPLRwheel\": \":HLRW\",\n",
    "            \":PPRRwheel\": \":HRRW\",\n",
    "        }\n",
    "        for pid in range(mesh.MNumParts):\n",
    "            tmp = mesh.PGetName(pid)\n",
    "            pname = rename_map.get(mesh.PGetName(pid), tmp)\n",
    "            mesh.PSetName(pid, pname)\n",
    "        mesh.MNumArts = 1\n",
    "        with open(fce_path_output, \"wb\") as f:\n",
    "            buf = mesh.IoEncode_Fce4M(False)\n",
    "            assert fc.ValidateFce(buf) == 1\n",
    "            f.write(buf)\n",
    "        del f\n",
    "        del mesh\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_SaveFceAsFce4.py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "\n",
    "    fce_path_current = fce_path_output"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert from FCE4 to FCE3, if applicable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_fce_version = GetFceVersion(fce_path_current)\n",
    "if current_fce_version == 4 and fce_version_target < 4:\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_PrintFceInfo.py'}\" \"{fce_path_current}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_MergeParts (Fce4 to Fce3, keep version).py'}\" \"{convertible_fce3}\" \"{transparent_windows_fce3}\" \"{fce_path_current}\" \"{fce_path_output}\"\n",
    "    !echo \"DONE bfut_MergeParts (Fce4 to Fce3, keep version).py\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_SortPartsToFce3Order (keep fce version).py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_RescaleModel.py'}\" \"{rescale_factor_fce3}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_ConvertDummies (to Fce3).py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_SaveFceAsFce3.py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "\n",
    "    fce_path_current = fce_path_output"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert from FCE3 to FCE4, if applicable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_fce_version = GetFceVersion(fce_path_current)\n",
    "if current_fce_version == 3 and fce_version_target > 3:\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_PrintFceInfo.py'}\" \"{fce_path_current}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_ConvertPartnames (Fce3 to Fce4).py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_ConvertDummies (Fce3 to Fce4).py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_SaveFceAsFce4.py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "\n",
    "    fce_path_current = fce_path_output"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert from FCE4 to FCE4M, if applicable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_fce_version = GetFceVersion(fce_path_current)\n",
    "if current_fce_version == 4 and fce_version_target > 5:\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_PrintFceInfo.py'}\" \"{fce_path_current}\"\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_ConvertPartnames (Fce4 to Fce4M).py'}\" \"{fce_path_output}\" \"{fce_path_output}\"\n",
    "    if os.path.isfile(fce_path_4Mpartorder_source):\n",
    "        with open(fce_path_4Mpartorder_source, \"rb\") as f:\n",
    "            if fc.ValidateFce(f.read()) == 1:\n",
    "                pass\n",
    "                !python \"{fcecodec_scriptsdir / 'bfut_MimicPartnamesAndPartsorder.py'}\" \"{fce_path_4Mpartorder_source}\" \"{fce_path_output}\"\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_SaveFceAsFce4M.py'}\" \"{fce_path_output}\" \"{fce_path_output}\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Validate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(fce_path_output, \"rb\") as f:\n",
    "    assert fc.ValidateFce(f.read()) == 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optionally copy colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if fce_copy_color:\n",
    "    pass\n",
    "    !python \"{fcecodec_scriptsdir / 'bfut_CopyCarColors.py'}\" \"{fce_path_colorsource}\" \"{fce_path_output}\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert FSH to TGA, if applicable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if input_fce_version == 5 and fce_version_target < 5 and len(fsh_path_input) > 0:\n",
    "    p = pathlib.Path(fsh_path_input)\n",
    "    car00tga_input = p.with_suffix(\".tga\")\n",
    "\n",
    "    !{fshtool_noprompt_exe} \"{fsh_path_input}\"\n",
    "    BMP = (p.parent / p.stem / \"0000\").with_suffix(\".BMP\")\n",
    "    BMPA = (p.parent / p.stem / \"0000-a\").with_suffix(\".BMP\")\n",
    "    !convert \"{BMP}\" \"{BMPA}\" -auto-orient -alpha off -compose CopyOpacity -composite \"{car00tga_input}\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert TGA alpha channel to target version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if platform.system().lower() == \"windows\":\n",
    "    pass\n",
    "    !copy \"{car00tga_input}\" \"{car00tga_output}\"\n",
    "else:\n",
    "    pass\n",
    "    !cp \"{car00tga_input}\" \"{car00tga_output}\"\n",
    "\n",
    "if texture_flip_vertically:\n",
    "    pass\n",
    "    !python \"{py_scriptsdir / 'bfut_TextureRotator/bfut_TextureRotator (flip vertically).py'}\" \"{car00tga_output}\" \"{car00tga_output}\"\n",
    "\n",
    "if fce_version_target == 3:\n",
    "    if input_fce_version == 4:\n",
    "        pass\n",
    "        !python \"{py_scriptsdir / 'bfut_NfsTgaConverter/bfut_NfsTgaConverter (HSto3).py'}\" \"{car00tga_output}\" \"{car00tga_output}\"\n",
    "    elif input_fce_version == 5:\n",
    "        pass\n",
    "        !python \"{py_scriptsdir / 'bfut_NfsTgaConverter/bfut_NfsTgaConverter (Mto3).py'}\" \"{car00tga_output}\" \"{car00tga_output}\"\n",
    "elif fce_version_target == 4:\n",
    "    if input_fce_version == 3:\n",
    "        pass\n",
    "        !python \"{py_scriptsdir / 'bfut_NfsTgaConverter/bfut_NfsTgaConverter (3toHS).py'}\" \"{car00tga_output}\" \"{car00tga_output}\"\n",
    "    elif input_fce_version == 5:\n",
    "        pass\n",
    "        !python \"{py_scriptsdir / 'bfut_NfsTgaConverter/bfut_NfsTgaConverter (MtoHS).py'}\" \"{car00tga_output}\" \"{car00tga_output}\"\n",
    "elif fce_version_target == 5:\n",
    "    if input_fce_version == 3:\n",
    "        pass\n",
    "        !python \"{py_scriptsdir / 'bfut_NfsTgaConverter/bfut_NfsTgaConverter (3toM).py'}\" \"{car00tga_output}\" \"{car00tga_output}\"\n",
    "    elif input_fce_version == 4:\n",
    "        pass\n",
    "        !python \"{py_scriptsdir / 'bfut_NfsTgaConverter/bfut_NfsTgaConverter (HStoM).py'}\" \"{car00tga_output}\" \"{car00tga_output}\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert TGA to FSH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# only applicable for conversion to FCE4M\n",
    "# a description of the procedure can be found in the \"bfut_Tga2Bmp.py\" APPENDIX section"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create VIV archive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python \"{unvivtool_script}\" e \"{viv_target_dir}\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```py\n",
    "# Copyright (C) 2023 and later Benjamin Futasz <https://github.com/bfut>\n",
    "#\n",
    "# This software is provided 'as-is', without any express or implied\n",
    "# warranty.  In no event will the authors be held liable for any damages\n",
    "# arising from the use of this software.\n",
    "#\n",
    "# Permission is granted to anyone to use this software for any purpose,\n",
    "# including commercial applications, and to alter it and redistribute it\n",
    "# freely, subject to the following restrictions:\n",
    "#\n",
    "# 1. The origin of this software must not be misrepresented; you must not\n",
    "#    claim that you wrote the original software. If you use this software\n",
    "#    in a product, an acknowledgment in the product documentation would be\n",
    "#    appreciated but is not required.\n",
    "# 2. Altered source versions must be plainly marked as such, and must not be\n",
    "#    misrepresented as being the original software.\n",
    "# 3. This notice may not be removed or altered from any source distribution.\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}