{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Advanced examples\n", "\n", "In this section we'll show several examples of usage of the `byteparsing` package for dealing with files combining ASCII and binary data." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Parsing PPM files\n", "\n", "To show how we can mix ASCII and binary data, we have an example where we parse Portable PixMap files (PPM). These files have a small ASCII header and the image itself in binary. The header looks something like this:\n", "\n", "```\n", "P6 # this marks the file type in the Netpbm family\n", "640 480\n", "256\n", "<>\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from dataclasses import dataclass\n", "from byteparsing import parse_bytes\n", "from byteparsing.parsers import (\n", " text_literal, integer, eol, named_sequence, sequence, construct,\n", " tokenize, item, array, fmap, text_end_by, optional)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The PPM header format allows for comments in the ASCII header." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "comment = sequence(text_literal(\"#\"), text_end_by(\"\\n\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We define a class that should contain all the data in the header." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class Header:\n", " width: int\n", " height: int\n", " maxint: int" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then we can construct a parser for this header, using `named_sequence` and `construct`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "header = named_sequence(\n", " _1 = tokenize(text_literal(\"P6\")),\n", " _2 = optional(comment),\n", " width = tokenize(integer),\n", " height = tokenize(integer),\n", " maxint = tokenize(integer)) >> construct(Header)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We'll have to pass on the header information to the parser for the binary blob somehow, so we define a function." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def image_bytes(header: Header):\n", " shape = (header.height, header.width, 3)\n", " size = header.height * header.width * 3\n", " return array(np.uint8, size) >> fmap(lambda a: a.reshape(shape))\n", "\n", "ppm_image = header >> image_bytes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's test this on a sample image, and ignore the fact that `PIL` has a perfectly good parser for PPM files itself." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "raw_data = open(\"python-logo.ppm\", \"rb\").read()\n", "image = parse_bytes(ppm_image, raw_data)\n", "\n", "from PIL import Image\n", "Image.frombytes(mode=\"RGB\", size=(image.shape[1], image.shape[0]), data=image)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Parsing PLY files\n", "\n", "PLY is a file format storing 3D polygonal data that has support for both ASCII and binary formats. Some references: [Wikipedia entry](https://en.wikipedia.org/wiki/PLY_(file_format)) and [Paul Bourke's pages](http://paulbourke.net/dataformats/ply/). The specification of the PLY format is a bit vague and allows for liberal interpretation and custom user defined fields. We take a look at the example on Paul Bourke's page:\n", "\n", "```\n", "ply\n", "format ascii 1.0 { ascii/binary, format version number }\n", "comment made by Greg Turk { comments keyword specified, like all lines }\n", "comment this file is a cube\n", "element vertex 8 { define \"vertex\" element, 8 of them in file }\n", "property float x { vertex contains float \"x\" coordinate }\n", "property float y { y coordinate is also a vertex property }\n", "property float z { z coordinate, too }\n", "element face 6 { there are 6 \"face\" elements in the file }\n", "property list uchar int vertex_index { \"vertex_indices\" is a list of ints }\n", "end_header { delimits the end of the header }\n", "0 0 0 { start of vertex list }\n", "0 0 1\n", "0 1 1\n", "0 1 0\n", "1 0 0\n", "1 0 1\n", "1 1 1\n", "1 1 0\n", "4 0 1 2 3 { start of face list }\n", "4 7 6 5 4\n", "4 0 4 5 1\n", "4 1 5 6 2\n", "4 2 6 7 3\n", "4 3 7 4 0\n", "```\n", "\n", "We see a header that is always ASCII encoded. The header specifies a list of *elements*, each containing a list of *properties*. The listed elements determine how to parse the data section of the PLY file. The data section maybe encoded in ASCII or binary." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from __future__ import annotations\n", "from typing import Optional\n", "from dataclasses import dataclass\n", "from functools import partial\n", "import numpy as np\n", "import pprint\n", "\n", "from byteparsing import (parse_bytes, Parser, parser)\n", "from byteparsing.parsers import (\n", " sequence, named_sequence, choice, optional, value, repeat_n,\n", " text_literal, char, text_one_of, text_end_by,\n", " byte_none_of, byte_one_of,\n", " flush, flush_decode,\n", " push, pop, char_pred,\n", " many, some, many_char, some_char, many_char_0, some_char_0,\n", " integer, scientific_number, array, binary_value,\n", " fmap, construct)\n", "\n", "pp = pprint.PrettyPrinter(indent=2, width=80)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Header\n", "\n", "The header starts with a \"magic number\", a line containing `ply`." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "eol = choice(text_literal(\"\\n\"), text_literal(\"\\n\\r\"))\n", "ply_magic_number = sequence(text_literal(\"ply\"), eol)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second line indicates which variation of the PLY format this is. We will store header information in data classes and enums." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "from enum import Enum\n", "\n", "class PlyFormat(Enum):\n", " ASCII = 1\n", " BINARY_LE = 2\n", " BINARY_BE = 3\n", " \n", " @staticmethod\n", " def from_string(format_str: str) -> PlyFormat:\n", " if format_str == \"ascii\":\n", " return PlyFormat.ASCII\n", " if format_str == \"binary_little_endian\":\n", " return PlyFormat.BINARY_LE\n", " if format_str == \"binary_big_endian\":\n", " return PlyFormat.BINARY_BE\n", " else:\n", " raise ValueError(f\"Unrecognized format string: {s}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since each item in the header is seperated by a newline, we need a `tokenize` function that doesn't skip newlines. From that we can define what we may consider to be a `word` in a PLY header. We `flush` the cursor, expect a `ascii_alpha` character (words don't start with numbers) and then many characters that are letters, numbers or underscores. At the end we `flush` the cursor again, decoding to a Python string. We see here both `many_char` and `many_char_0` being used: `many_char` automatically flushes the cursor before and after which is not what we want when parsing a word. In fact, the only thing `many_char_0` does, is to move the cursor end until the given parser no longer matches the input." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "ascii_alpha = char_pred(lambda c: 64 < c < 91 or 96 < c < 123)\n", "ascii_num = char_pred(lambda c: 48 <= c < 58)\n", "ascii_alpha_num = choice(ascii_alpha, ascii_num)\n", "ascii_underscore = char(95)\n", "\n", "\n", "def tokenize(p: Parser) -> Parser:\n", " return sequence(p >> push, many_char(text_one_of(\" \")), pop())\n", "\n", "word = sequence(\n", " flush(), ascii_alpha, many_char_0(choice(ascii_alpha_num, ascii_underscore)),\n", " flush_decode())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The format line specifies the used data encoding: one of `ascii`, `binary_little_endian` or `binary_big_endian`, and a version number. The version number is always \"1.0\"." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "ply_format = named_sequence(\n", " _1 = tokenize(text_literal(\"format\")),\n", " format_str = tokenize(word),\n", " _2 = sequence(tokenize(text_literal(\"1.0\")), eol)) \\\n", ">> construct(PlyFormat.from_string)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_bytes(ply_format, b\"format binary_little_endian 1.0\\n\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Comments may be placed in the header by using the word comment at the start of the line. Everything from there until the end of the line should then be ignored." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "ply_comment = sequence(\n", " tokenize(text_literal(\"comment\")), flush(),\n", " text_end_by(\"\\n\") >> push, optional(char(\"\\r\")), pop())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need a parser for a data type, and given a data type we need to be able to parse that data either in ASCII or binary. There are two classes of types: primitive types and list types." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "ply_type_table = {\n", " \"char\": \"int8\",\n", " \"uchar\": \"uint8\",\n", " \"short\": \"int16\",\n", " \"ushort\": \"uint16\",\n", " \"int\": \"int32\",\n", " \"uint\": \"uint32\",\n", " \"float\": \"float32\",\n", " \"double\": \"float64\"\n", "}\n", "\n", "class PlyType:\n", " pass\n", "\n", "@dataclass\n", "class PlyPrimitiveType(PlyType):\n", " dtype: np.dtype\n", " \n", " @staticmethod\n", " def from_string(s: str) -> PlyPrimitiveType:\n", " sanitized_name = ply_type_table.get(s, s)\n", " return PlyPrimitiveType(np.dtype(sanitized_name))\n", " \n", " @property\n", " def byte_size(self) -> int:\n", " return self.dtype.itemsize\n", " \n", " def ascii(self) -> Parser:\n", " return sequence(\n", " flush(), some_char_0(byte_none_of(b\"\\n \")),\n", " many_char_0(byte_one_of(b\"\\n \")), flush(self.dtype.type))\n", " \n", " def binary(self) -> Parser:\n", " return binary_value(self.dtype)\n", " \n", "@dataclass\n", "class PlyListType(PlyType):\n", " size_type: PlyPrimitiveType\n", " value_type: PlyPrimitiveType\n", " \n", " def ascii(self) -> Parser:\n", " return self.size_type.ascii() >> partial(repeat_n, self.value_type.ascii())\n", " \n", " def binary(self) -> Parser:\n", " return binary_value(self.size_type.dtype) >> partial(array, self.value_type.dtype)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "primitive_type = tokenize(word) >> fmap(PlyPrimitiveType.from_string)\n", "\n", "list_type = named_sequence(\n", " _1=tokenize(text_literal(\"list\")),\n", " size_type=primitive_type,\n", " value_type=primitive_type) >> construct(PlyListType)\n", "\n", "ply_type = choice(list_type, primitive_type)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PlyPrimitiveType(dtype=dtype('float32'))" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_bytes(ply_type, b\"float float\")" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')), value_type=PlyPrimitiveType(dtype=dtype('float32')))\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_type, b\"list uint8 float\"))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PlyProperty:\n", " dtype: PlyType\n", " name: str\n", "\n", "ply_property = named_sequence(\n", " _1=tokenize(text_literal(\"property\")),\n", " dtype=ply_type,\n", " name=tokenize(word),\n", " _2=eol) >> construct(PlyProperty)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='x')" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_bytes(\n", " ply_property,\n", " b\"property float x\\n\")" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "end_header = sequence(text_literal(\"end_header\"), eol)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PlyElement:\n", " name: str\n", " size: int\n", " properties: List[PlyProperty]\n", " \n", " def ascii(self) -> Parser:\n", " single_item = named_sequence(\n", " **{p.name: p.dtype.ascii() for p in self.properties})\n", " return repeat_n(single_item, self.size)\n", " \n", " @property\n", " def afine(self) -> bool:\n", " return all(isinstance(p.dtype, PlyPrimitiveType)\n", " for p in self.properties)\n", " \n", " def binary(self) -> Parser:\n", " if self.afine:\n", " compound_type = [(p.name, p.dtype.dtype) for p in self.properties]\n", " return array(compound_type, self.size)\n", " else:\n", " single_item = named_sequence(\n", " **{p.name: p.dtype.binary() for p in self.properties})\n", " return repeat_n(single_item, self.size)\n", " \n", "\n", "ply_element = named_sequence(\n", " _1=tokenize(text_literal(\"element\")),\n", " name=tokenize(word),\n", " size=tokenize(integer),\n", " _2=eol,\n", " properties=some(ply_property)) >> construct(PlyElement)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ PlyElement(name='vertex', size=8, properties=[PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='x'), PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='y'), PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='z')]),\n", " PlyElement(name='face', size=6, properties=[PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')), value_type=PlyPrimitiveType(dtype=dtype('int32'))), name='vertex_index')])]\n" ] } ], "source": [ "pp.pprint(\n", " parse_bytes(\n", " some(ply_element), \n", " b\"element vertex 8\\nproperty float x\\nproperty float y\\nproperty float z\\n\" +\n", " b\"element face 6\\nproperty list uchar int vertex_index\\n\"))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PlyElement(name='face', size=6, properties=[PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')), value_type=PlyPrimitiveType(dtype=dtype('int32'))), name='vertex_index')])\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_element, b\"element face 6\\nproperty list uchar int vertex_index\\n\"))" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PlyHeader:\n", " format: PlyFormat\n", " comment: List[str]\n", " elements: List[PlyElement]\n", " \n", " def parser(self) -> Parser:\n", " if self.format == PlyFormat.ASCII:\n", " return named_sequence(\n", " **{e.name: e.ascii() for e in self.elements})\n", " if self.format == PlyFormat.BINARY_LE:\n", " return named_sequence(\n", " **{e.name: e.binary() for e in self.elements})\n", " else:\n", " raise NotImplementedError()\n", "\n", "ply_header = named_sequence(\n", " _1=ply_magic_number,\n", " format=ply_format,\n", " comment=many(ply_comment),\n", " elements=some(ply_element),\n", " _2=sequence(text_literal(\"end_header\"), eol)) >> construct(PlyHeader)\n", "\n", "def ply_data(header):\n", " return named_sequence(header=value(header), data=header.parser())\n", "\n", "ply_file = ply_header >> ply_data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following ASCII example is given on Paul Bourke's page." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "ascii_example = b\"\"\"ply\n", "format ascii 1.0\n", "comment made by Greg Turk\n", "comment this file is a cube\n", "element vertex 8\n", "property float x\n", "property float y\n", "property float z\n", "element face 6\n", "property list uchar int vertex_index\n", "end_header\n", "0 0 0\n", "0 0 1\n", "0 1 1\n", "0 1 0\n", "1 0 0\n", "1 0 1\n", "1 1 1\n", "1 1 0\n", "4 0 1 2 3\n", "4 7 6 5 4\n", "4 0 4 5 1\n", "4 1 5 6 2\n", "4 2 6 7 3\n", "4 3 7 4 0\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PlyHeader(format=, comment=['made by Greg Turk', 'this file is a cube'], elements=[PlyElement(name='vertex', size=8, properties=[PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='x'), PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='y'), PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='z')]), PlyElement(name='face', size=6, properties=[PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')), value_type=PlyPrimitiveType(dtype=dtype('int32'))), name='vertex_index')])])\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_header, ascii_example))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "No for the fun part! The header that we read actually encodes the parser for the rest of the file!" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{ 'data': { 'face': [ {'vertex_index': [0, 1, 2, 3]},\n", " {'vertex_index': [7, 6, 5, 4]},\n", " {'vertex_index': [0, 4, 5, 1]},\n", " {'vertex_index': [1, 5, 6, 2]},\n", " {'vertex_index': [2, 6, 7, 3]},\n", " {'vertex_index': [3, 7, 4, 0]}],\n", " 'vertex': [ {'x': 0.0, 'y': 0.0, 'z': 0.0},\n", " {'x': 0.0, 'y': 0.0, 'z': 1.0},\n", " {'x': 0.0, 'y': 1.0, 'z': 1.0},\n", " {'x': 0.0, 'y': 1.0, 'z': 0.0},\n", " {'x': 1.0, 'y': 0.0, 'z': 0.0},\n", " {'x': 1.0, 'y': 0.0, 'z': 1.0},\n", " {'x': 1.0, 'y': 1.0, 'z': 1.0},\n", " {'x': 1.0, 'y': 1.0, 'z': 0.0}]},\n", " 'header': PlyHeader(format=, comment=['made by Greg Turk', 'this file is a cube'], elements=[PlyElement(name='vertex', size=8, properties=[PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='x'), PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='y'), PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='z')]), PlyElement(name='face', size=6, properties=[PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')), value_type=PlyPrimitiveType(dtype=dtype('int32'))), name='vertex_index')])])}\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_file, ascii_example))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### The Stanford Bunny\n", "\n", "Now that we have the capability to parse binary PLY files, we can load the Stanford Bunny. For visualisation purposes it helps to know that all faces in this file are triangles." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "\n", "bunny = parse_bytes(ply_file, Path(\"_static/stanford_bunny.ply\").open(mode=\"rb\").read())" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "vertices = bunny[\"data\"][\"vertex\"].view((np.float32, 3))\n", "triangles = np.array([row[\"vertex_indices\"] for row in bunny[\"data\"][\"face\"]])" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "from mpl_toolkits import mplot3d\n", "from matplotlib import pyplot as plt\n", "# For interactive use: install ipympl and run:\n", "# %matplotlib widget" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(12,12))\n", "ax = plt.axes(projection=\"3d\")\n", "ax.azim = -18\n", "ax.elev = 15\n", "ax.plot_trisurf(*vertices.T[[2,0,1]], triangles=triangles);" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Parsing Memory mapped OpenFOAM files\n", "\n", "The final example is to read an OpenFOAM file as a memory mapped array. There are some details that need attention.\n", "\n", "```python\n", "import mmap\n", "import numpy as np\n", "from byteparsing import parse_bytes\n", "from byteparsing.openfoam import foam_file\n", "\n", "f = Path(\"pipeFlow/1.0/U\").open(mode=\"r+b\")\n", "with mmap.mmap(f.fileno(), 0) as mm:\n", " content = parse_bytes(foam_file, mm)\n", " result = content[\"data\"][\"internalField\"]\n", "\n", " <>\n", "\n", " del result\n", " del content\n", "```\n", "\n", "The content is returned in the form of a nested dictionary. The `\"internalField\"` item is a name that one often finds in OpenFOAM files. The `result` object is a Numpy `ndarray` created using a `np.frombuffer` call. Any mutations to the Numpy array are directly reflected on the disk. This means that accessing large amounts of data can be extremely efficient in terms of memory footprint.\n", "\n", "The final two `del` statements are necessary to ensure that no reference to the memory-mapped data outlives the memory map itself, which is closed as soon as we leave the `with mmap ...` context." ] } ], "metadata": { "kernelspec": { "display_name": "byteparsing", "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.13" }, "vscode": { "interpreter": { "hash": "3e598a5da089da4c53124f7e6f7bf0c3ac5c5ab4965502396b4a9dfe31dcfb28" } } }, "nbformat": 4, "nbformat_minor": 4 }