From 00f9b4aa91a78b84144da871fa4f0ef76afb3b91 Mon Sep 17 00:00:00 2001 From: Aleksandr Dremov Date: Fri, 10 Nov 2023 17:41:31 +0300 Subject: [PATCH] better pyplot support --- README.md | 42 ++++++--- examples/.gitignore | 1 + examples/chunks.ipynb | 170 ++++++++++++++++++++++++++++++++++ examples/display.ipynb | 140 ++++++++++++++++++++++++++++ examples/display_custom.ipynb | 134 +++++++++++++++++++++++++++ examples/hello_world.ipynb | 120 ++++++++++++++++++++++++ examples/monitor.ipynb | 140 ++++++++++++++++++++++++++++ examples/plot.ipynb | 147 +++++++++++++++++++++++++++++ igogo/context.py | 12 ++- igogo/core.py | 30 ++++-- igogo/output.py | 35 ++++++- igogo/yielder.py | 2 + pyproject.toml | 9 +- 13 files changed, 953 insertions(+), 29 deletions(-) create mode 100644 examples/.gitignore create mode 100644 examples/chunks.ipynb create mode 100644 examples/display.ipynb create mode 100644 examples/display_custom.ipynb create mode 100644 examples/hello_world.ipynb create mode 100644 examples/monitor.ipynb create mode 100644 examples/plot.ipynb diff --git a/README.md b/README.md index 40b97ec..0f40b05 100644 --- a/README.md +++ b/README.md @@ -78,11 +78,13 @@ Decorator `@igogo.job` has several useful parameters. Allows to set how to render output. Possible options: `text`, `markdown`, `html` Default: `text` - `displays`\ As igogo job modify already executed cell, it needs to have spare placeholders for rich output. - This parameter specifies how many spare displays to spawn. Default: `10` + This parameter specifies how many spare displays to spawn. Default: `1` - `name`\ User-friendly name of igogo job. - `warn_rewrite`\ Should warn rewriting older displays? Default: `True` +- `auto_display_figures`\ + Should display pyplot figures created inside igogo automatically? Default: `True` Markdown example: @@ -90,8 +92,9 @@ https://user-images.githubusercontent.com/25539425/227203729-af94582c-8fe2-40fe- ### Display Additional Data -You can use `igogo.display` inside a job to display additional content. -For example, you can show pyplot figures. +Pyplot figures will be automatically displayed in igogo cell. + +You can also use `igogo.display` inside a job to display any other content or several figures. Mind that displays must be pre-allocated by specifying displays number in `igogo.job(displays=...)` ```python import numpy as np @@ -99,18 +102,23 @@ import matplotlib.pyplot as plt import igogo def experiment(name, f, i): - x = np.linspace(0.01, i, 1000) - fig, ax = plt.subplots(figsize=(5, 1)) - ax.plot(x, f(x), c='r') - ax.set_title(name) - - # display figure to job's output. - # if called from outside job, falls back to - # IPython.display.display - igogo.display(fig) - # close pyplot so that it does not show content - # automatically - plt.close() + x = np.linspace(0, i / 10, 100) + fig = plt.figure() + plt.plot( + x, + f(x) + ) + plt.gca().set_title(name) + igogo.display(fig) + + fig = plt.figure() + plt.scatter( + x, + f(x) + ) + plt.gca().set_title(name) + igogo.display(fig) + igogo.sleep(0.05) ``` As noted in "Configure jobs" section, `igogo` jobs have limited number of displays. @@ -168,6 +176,10 @@ Runs but has problems with output from igogo jobs. Jobs are executed, but there ## More Examples +[**Check out pretty notebooks**](https://github.com/alexdremov/igogo/tree/main/examples) + +--- + ### Train model and check metrics https://user-images.githubusercontent.com/25539425/227651626-cba8a317-a986-4971-9639-84cdb388e2d3.mov diff --git a/examples/.gitignore b/examples/.gitignore new file mode 100644 index 0000000..58461f2 --- /dev/null +++ b/examples/.gitignore @@ -0,0 +1 @@ +.ipynb_checkpoints \ No newline at end of file diff --git a/examples/chunks.ipynb b/examples/chunks.ipynb new file mode 100644 index 0000000..44c26f1 --- /dev/null +++ b/examples/chunks.ipynb @@ -0,0 +1,170 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "e94f1c52-fd29-4994-8d52-6a2faa825931", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The igogo extension is already loaded. To reload it, use:\n", + " %reload_ext igogo\n" + ] + } + ], + "source": [ + "%load_ext igogo\n", + "import igogo\n", + "import numpy as np\n", + "from tqdm.auto import tqdm\n", + "\n", + "raw_data = np.random.randn(5000000, 100)\n", + "\n", + "igogo_yield_freq = 32\n", + "igogo_first_step_cache = []\n", + "\n", + "result = []" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c9a8edfc-dd51-420a-81a5-7f6c9fb3ae63", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d733eaa11ef44ca7991070c62f13d653", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/5000000 [00:00 0 and i % igogo_yield_freq == 0:\n", + " igogo.yielder() # allow other jobs to execute" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9baf82be-5ef3-49ad-9006-2f026ee1a782", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1130932025094e7f9e9a43a76d49e820", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/5000000 [00:00= len(igogo_first_step_cache): # wait for producer to process data\n", + " igogo.yielder()\n", + " \n", + " result.append(np.mean(igogo_first_step_cache[i]))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eee93ec9-491e-485a-8af8-1cc608ccd271", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/display.ipynb b/examples/display.ipynb new file mode 100644 index 0000000..29b21d4 --- /dev/null +++ b/examples/display.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a003eda2-876e-43fb-8f36-291d0e466fc2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "%load_ext igogo\n", + "import igogo" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2d97b237-f9bf-44c3-bd54-3fe5240614bc", + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return np.sin(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "780a0158-c8b1-4d77-84db-14a49dc4246e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABipklEQVR4nO3deVhTZ9o/8G82EtawE1AQwQWpO1aKeystVKfVaaetM7ZWx9G3izO19u3izNTOdHO6TH/ztnVqF+0y3TszdrEt1lL3BRTFBUHBDRTCKoRFEpKc3x8hUSoqaJKTnHw/15Wrl+EkuZPCyX2e+3nuRyYIggAiIiIiCZGLHQARERGRszHBISIiIslhgkNERESSwwSHiIiIJIcJDhEREUkOExwiIiKSHCY4REREJDlMcIiIiEhylGIHIAar1YrKykoEBwdDJpOJHQ4RERH1gCAIaG5uRlxcHOTyS4/R+GSCU1lZifj4eLHDICIioitQUVGBvn37XvIYn0xwgoODAdg+oJCQEJGjISIiop4wGAyIj493fI9fik8mOPayVEhICBMcIiIiL9OT6SWcZExERESSwwSHiIiIJIcJDhEREUkOExwiIiKSHCY4REREJDlMcIiIiEhymOAQERGR5DDBISIiIslhgkNERESS49IEZ/PmzbjlllsQFxcHmUyGL7/88rKP2bhxI0aPHg21Wo0BAwbgvffeu+CYFStWIDExERqNBunp6cjPz3d+8EREROS1XJrgtLa2YsSIEVixYkWPjj9+/DimT5+O66+/HoWFhVi8eDF+97vfYd26dY5jPvvsMyxZsgRPPfUU9uzZgxEjRiArKws1NTWuehtERETkZWSCIAhueSGZDGvWrMHMmTMveszjjz+Ob7/9FgcPHnTcN2vWLDQ2NiInJwcAkJ6ejmuvvRavv/46AMBqtSI+Ph6///3v8cQTT/QoFoPBAK1Wi6amJu5FRURE5CV68/3tUZtt7tixA5mZmV3uy8rKwuLFiwEAJpMJBQUFWLp0qePncrkcmZmZ2LFjx0Wf12g0wmg0Ov5tMBicGzhdVLWhHWU1LWhoNaGxzYSG1g60mcwYGR+KCQMjEaxRiR0iEUlMh8WKraV1qGw6C4tVcNwUchkmDozCgOggsUMkN/CoBEev1yMmJqbLfTExMTAYDDh79izOnDkDi8XS7TElJSUXfd7ly5fjr3/9q0tipu4VnDyDVVuPIeegHtaLjBGqFDJcmxiO6wdHI3uoDvHhAe4NkogkpbS6GZ/vrsCavadR12K66HFD+4Rgxog+uGVEHHRajRsjJHfyqATHVZYuXYolS5Y4/m0wGBAfHy9iRNJksQrIOajHO1uPYW95o+P+5KhARASpER7gh7BAP8hlwPaj9The14rtR+ux/Wg9XsgpwQPXD8Ci6wfAT8nFfUTUc5uP1OKV9UdQWNHouC8ySI1RCaFQKWRQyOVQyICGtg5sL6vDwdMGHDxtwPPfF2NqSjSe++UwxIQw0ZEaj0pwdDodqquru9xXXV2NkJAQ+Pv7Q6FQQKFQdHuMTqe76POq1Wqo1WqXxEw2Da0mPPjRHuw4Vg8A8FPIMXNUHH47oT9SdN3XSY/XtWJDSQ3WFemRd7wBr+aWYt1BPV66YziG9w11Y/RE5I3MFiv+vv4I3th4FACglMtwQ0o07hgTjymDo6BSXHix1NBqwrcHqvDV3tPYffIMfiyuQcHJzXjxVyNwY2rMBceT9/KoBCcjIwPfffddl/vWr1+PjIwMAICfnx/S0tKQm5vrmKxstVqRm5uLRYsWuTtc6lRU2YSFHxTgdONZBPopMH9iEu65rh+igi+dVPaPDET/Cf0xb3wivj1Qhae+KsLh6mbMXLENCyclY3HmQGhUCje9CyLyJpWNZ/GHT/Zi98kzAIC7r0vAQ1MHXfa8Ex7oh3uu64d7ruuHI9XNePizQhRVGrDgg92457p++NP0ITzvSIRLawEtLS0oLCxEYWEhANsy8MLCQpSXlwOwlY7mzJnjOP6+++7DsWPH8Nhjj6GkpAT//Oc/8fnnn+Phhx92HLNkyRK8/fbbeP/991FcXIz7778fra2tmDdvnivfCl3EN/sqcfsb23G68SwSIwKw5sHxWHLj5U8y55PJZPjF8Dj88PAk3DoiDlYBWLnpKO5dnY82k9mF0RORN/qppBrTXt2C3SfPIFitxD9nj8azM4f16rwDAINigvHfB8ZhwcT+AIB/7TyJW17birKaFleETW7m0mXiGzduxPXXX3/B/ffeey/ee+89zJ07FydOnMDGjRu7PObhhx/GoUOH0LdvXzz55JOYO3dul8e//vrreOmll6DX6zFy5Ei8+uqrSE9P73FcXCZ+9QRBwEvrDuOfnUPDkwZF4bVZo6ANuPpVUT8U6fHI5/vQbDQjIykCq+deC38/XlEREfBV4Wk89GkhAGBYHy1e/80o9IsIvOrn3VJaiyWf70NtsxExIWr8+75xXPjggXrz/e22PjiehAnO1fvHj0fwjx9LAQD/MykJj2WnQCGXOe3595SfwZxV+WgxmjFxYCTenjOGw8ZEPm7zkVr89r1dMFsF3DUmHk/PvAZqpfPOC3UtRsx+Ow+Hq5vRLyIAX9yXgehgTj72JL35/uZyFeq1NXtPOZKbZ2YOxdJpQ5ya3ADA6IQwvDfvWgT4KbCltA7/868CGM0Wp74GEXmPfRWNuO/DApitAm4dEYfltw1zanID2FZefTB/LOLD/XGyvg1zVuWjqa3Dqa9B7sMEh3pl57F6PPbv/QCA+yYn457r+rnstcYkhuPdudfCX6XApiO1uP/DPeiwWF32ekTkmY7VtmDee7vQZrJgwoBIvHzHCMidfFFlFxOiwYfz0xEVrEaJvhm/fX8X5wJ6KSY41GNHa1vwP/8qQIdFwLRhOjyWNdjlr5neOQdHo5Ljp5Ia/L/1R1z+mkTkOaoN7bhnVT4aWk0Y1keLlfekubxXVr+IQPxr/liEaJQoOHkG9324B2ZeXHkdJjjUI/UtRsx7dxeaznZgVEIoXrlzpMuuoH4uIzkCr9w5EgDwxqaj2Fpa55bXJSJxdVisWPivAscqzXfnXYsgtXu6m6ToQvDuvLHwVymw+UgtVmw46pbXJedhgkOXJQgCHvq0EOUNbYgP9xdlwu+0YbH49dgECALw8OeFqGsxXv5BROTV/rnhKPZVNCJEo8QHv01HZJB7G7am9QvD8tuGAQBe/akUe8vPuPX16eowwaHL+ji/HFvL6qBRybH63mvdfpKxW/aLVAyKCUJtsxGPfL4P1ottckVEXm//qUa8+tO5xQwJEeIs2Z4xMg63jIiDxSrg4c8K0WrkfBxvwQSHLunUmTY8/20xAOCxrBQMjAkWLRZ/PwVe/81oqJVybDpSi3e2HhMtFiJynfYOCx7+rBAWq4Dpw2Nx64g40WKRyWR4dsZQxGo1OFHfhmc7z4fk+Zjg0EUJgoAn/nMArSYLxvQLw9xxiWKHhEExwVh2SyoA4MWcw9h33uZ6RCQNL+SU4GhtK6KD1Xh2xlDIZO6Z73cx2gAV/n7nCMhkwCf55Vh/qPryDyLRMcGhi/p0VwW2ltVBrZTjxV8Nd9uk4sv5zdgETBumg9kqYMnnhVw6TiQh28rq8O62EwCAF341HGGBfuIG1GlcciQWTEwCADz+n/2oaW4XOSK6HCY41K3TjWfxXOdQ7KNZg5EUFSRyROfIZDIs/+VwRAT64WhtK97ffkLskIjICQztHfjfL/YBAGanJ+D6wdEiR9TVIzcNQoouGA2tJiz7skjscOgymODQBQRBwNL/HkCL0YzRCaGYN76/2CFdQBugwmPZtj48//djKWqbuaqKyNu9+mMpqpra0S8iAH+cNkTscC6gVirwj1kjoZDLkFOkx/ajbFnhyZjg0AXW7q/C5iO18FPK8dIdI5y+DYOz3JEWj+F9tWg2mvFCTonY4RDRVThR14r3d5wAADw9YygC3dTvprdSdCH4zdgEAMCza4th4WpOj8UEh7owmi14cZ0tWXhwygAke1Bp6ufkchn+eus1AIB/F5xijwoiL/a370vQYREweVAUJg+KEjucS3r4xkEI1ihxqMqAfxdUiB0OXQQTHOrio53lqGg4i6hgNRZM8rzS1M+NSgjDr9L6AgD+8nURe+MQeaH84w3IKdJDLgP+NN3zSlM/Fx7oh4emDgQAvLTuCJrbuSGnJ2KCQw6G9g681tlY6+HMQQjw88wh4p97LHswgtRK7DvVhH8XnBI7HCLqBatVwLPfHgIAzBqbgEEi9trqjTkZiegfGYi6FiP+uZHbOHgiJjjksHLjUZxp60ByVCDuHNNX7HB6LDpYg8WZtqupF3JK0HSWV1NE3uKrfaex/1QTgtRKPJw5SOxwesxPKcefOidCr9pyHBUNbSJHRD/HBIcAAFVNZ7Fq63EAwOPZKVAqvOtX495xiRgQHYT6VpPjfRCRZztrsuDFnMMAgAeuT0ZUsDjbwFypqUOiMX5ABEwWK5Z/zw7Hnsa7vsXIZf7f+iMwmq24NjEMN6bGiB1Or6kUcjxyo+3q791txzmKQ+QFVm09hqqmdvQJ9cdvPbAdxeXIZDL8eXoq5DLguwN6FJzkQgdPwgSHcFjf7Ji78sTNQ0Rvi36lsq7RYXBMMJrbzXh3G0dxiDxZU1sHVm6y7Sf3+M0p0KgUIkd0ZYbEhjgWOrzeOYeRPAMTHMJL60pgFYCbh+qQ1i9M7HCumFwuw++nDgAArN56HAaubCDyWB/sOIEWoxmDY4Lxi2GxYodzVR6YMgByGbDhcC0Onm4SOxzqxATHxxVXGfBjcQ3kMuB/swaLHc5VmzY0FgOjg2BoN+P9zv1siMiztJnMWN05yvrA9ckes8/dlUqMDMQtnTuer9hQJnI0ZMcEx8et3GRb3njzsFiPburXU7ZRHNuKqne2Hmd/CiIP9El+Bc60dSAxIgC/GB4ndjhO8eD1ttHj7w/qUVrdLHI0BDDB8WkVDW1Yu78KAHD/5GSRo3Ge6cNikRwViKazHfhgx0mxwyGi8xjNFry12XZhdd/kZI/dCqa3BsUEI/saHQCwL46HYILjw97ZcgwWq4AJAyIxtI9W7HCcRiGX4fc32EZx3t5yDC1Gs8gREZHdf/ecRrXBCF2IBr8c3UfscJzKPorzVeFpnKxvFTkaYoLjo+pbjPhst20PlfunSGf0xu6WEXFIigxEY1sHPujcwI+IxGW2WB1l8QWTkqBWeufKqYsZ1leLKYOjYBWANziKIzomOD7q/e0n0N5hxbA+WoxLjhA7HKdTyGVYdIPtamrVluNo77CIHBERfXugCifr2xAe6Idfj40XOxyXWNQ5ivOfPadQ2XhW5Gh8GxMcH9RqNOP9zrkp901O9tq+N5dz64g4xGk1qG81OeYaEZE4rFYB/9xgG9X47fhEr9nrrrfGJIbjuqRwdFgEvLX5mNjh+DQmOD7o010VaDprW8GQPVQndjguo1TIcXdGPwC27saCwJ3GicTyU0kNDlc3I0itxD0ZiWKH41KLrrfNAfys81xL4mCC42NMZive2WK7qlg4STorGC7m19cmQK2Uo6jSgN1so04kmne32/rezL4uAVp/lcjRuNb4AREYFBOEsx0W/KezSzy5HxMcH/PtgUpUNbUjKliN2yS2gqE7YYF++OUo2/vk9g1E4iiracG2snrIZcA91/UTOxyXk8lkmNM5SvXBjhOwWjl6LAYmOD7G3hdmznX9vHbvl96aOz4RALCuqBqnOemPyO0+3Gk779yQEoO+YQEiR+MevxzVB8EaJU7Ut2Fzaa3Y4fgktyQ4K1asQGJiIjQaDdLT05Gfn3/RY6dMmQKZTHbBbfr06Y5j5s6de8HPs7Oz3fFWvFpRZRP2ljdCKZfhLomuYOhOii4EGUkRsFgF/IuN/4jcqsVodpRp7h0n/dEbu0C1Enek2c6zbDgqDpcnOJ999hmWLFmCp556Cnv27MGIESOQlZWFmpqabo//73//i6qqKsft4MGDUCgUuOOOO7ocl52d3eW4Tz75xNVvxet9uLMcAJA1VIfoYI3I0bjXvM5RnE93leOsiUvGidxlzd7TaDaakRQZiPHJkWKH41b3dC5y2HC4ho3/RODyBOeVV17BggULMG/ePKSmpmLlypUICAjA6tWruz0+PDwcOp3OcVu/fj0CAgIuSHDUanWX48LCvHcXbHdobu/AV4WnAfhGDfznpg6JQXy4PxrbOvBl5+dARK4lCAL+1dlo8+7r+nn9ppq91T8yEFMGR0EQwNFjEbg0wTGZTCgoKEBmZua5F5TLkZmZiR07dvToOVatWoVZs2YhMDCwy/0bN25EdHQ0Bg8ejPvvvx/19fUXfQ6j0QiDwdDl5mvW7D2NNpMFA6ODkN4/XOxw3E4hl+Hezkl/7207wSXjRG6Qd7wBR6pb4K9S4Pa0vmKHIwr7eefz3RVoM3HbGHdyaYJTV1cHi8WCmJiYLvfHxMRAr9df9vH5+fk4ePAgfve733W5Pzs7Gx988AFyc3PxwgsvYNOmTbj55pthsXRfeli+fDm0Wq3jFh/vO/NPAPtVlO3qYXZ6gmQb+13OHWPiEeCnwOHqZuw4evGEmIicw37e+eXoPpJfGn4xkwdFoV9EAAztZny5t1LscHyKR6+iWrVqFYYNG4axY8d2uX/WrFm49dZbMWzYMMycORNr167Frl27sHHjxm6fZ+nSpWhqanLcKioq3BC958g/3oDSGttV1G0+ehUFAFp/lWNp/Ce7fOt3gMjd9E3tWFdku5Cdk+F7ZXE7uVzmmBbwwQ6OHruTSxOcyMhIKBQKVFdXd7m/uroaOt2lO+i2trbi008/xfz58y/7OklJSYiMjERZWVm3P1er1QgJCely8yUf5tkmF88YGYcQjW9eRdnNujYBALCuSI/GNpPI0RBJ18f55TBbBYxNDEeKzrfOuT93R1o8/FUKlOibkX+8QexwfIZLExw/Pz+kpaUhNzfXcZ/VakVubi4yMjIu+dgvvvgCRqMRd99992Vf59SpU6ivr0dsbOxVxyw1tc1G5By07cN0tw9OLv65oX20SI0NgclsxZd7OdmYyBU6LFZ8km+7sLrHh0dv7LQBKswYGQcA+Gw3R4/dxeUlqiVLluDtt9/G+++/j+LiYtx///1obW3FvHnzAABz5szB0qVLL3jcqlWrMHPmTEREdN3puqWlBY8++ih27tyJEydOIDc3FzNmzMCAAQOQlZXl6rfjdT7fXYEOi4CR8aEY2kcrdjge4c4xtjLdZ7tPcbiYyAU2Ha5FbbMRkUF+yLpGuvvd9cYdY2xzP78/oEdzO/encgeXJzh33XUXXn75ZSxbtgwjR45EYWEhcnJyHBOPy8vLUVXVdafnw4cPY+vWrd2WpxQKBfbv349bb70VgwYNwvz585GWloYtW7ZArVa7+u14FatVcFxFcfTmnJmj+sBPKUdxlQFFlb63oo7I1f7d2djvl51/awSMTghFclQgznZY8O3+qss/gK6aW/arX7RoERYtWtTtz7qbGDx48OCLXln7+/tj3bp1zgxPsnYeq8epM2cRrFHiF8NZvrMLDbBdVX6zrxKf7argyBaREzW0mpBbYpt36atLw7sjk8lwx5h4/O37EnxRcAqzxiaIHZLkMbWWsP/ssc0x+cXwOJ/Zd6qn7uocLv6y8DTaO9jZmMhZvio8jQ6LgGF9tD4/ufjnbhvVBwq5DAUnz+BobYvY4UgeExyJajWa8X3n5OJfpUl/1/DeGpccgb5h/mhuNyPn4OV7MhFRz9jLU3eM4ejNz0WHaDB5UBSAc58TuQ4THInKOahHm8mCxIgAjE7gNhY/J5fLHBvhfc5VDUROcajSNq/NTyHHrSPixA7HI93RWbb7755TsFi5yMGVmOBI1H/22K4Obhvd12c7F1/Or8b0hUwGbD9aj/L6NrHDIfJ69lGJG1NjEBrgJ3I0nmnqkBiEBahQbTBic2mt2OFIGhMcCTrdeBY7jtm2IvjlKJanLqZPqD8mDLDtbvxFAUdxiK6GyWx1bGT7K04uvig/pRwzRtrOy//ezTKVKzHBkaA1e05BEIDrksIRHx4gdjge7a5rbWWqfxdwuJjoamw4XIOGVhOig9WYODBS7HA82p2dixzWH6rGmVZ2VHcVJjgSIwiCY/XU7aN5FXU5N6bGQOuvQlVTO1uoE10FR++b0X2gVPCr5VJS40JwTVwITBYrvipkR3VX4W+hxOwpb8Txulb4qxS4eRh731yOWqnAtGG2Tqs80RBdmboWIzaU1AA4N4mWLs3+OX3B1VQuwwRHYuyTi7OH6hCkdksfR6936whbPfy7A1UwmtkTh6i3viqshNlq2xJmQHSw2OF4hRkj+0Apl6Go0oCyGvbEcQUmOBLS3mHB2n2VAFie6o2x/cOhC9HA0G7GpsNc1UDUW/bRz9tHc1FDT4UF+mFSZ0+crzvP2+RcTHAkJLe4BoZ2M2K1GmQkR1z+AQQAUMhluGWErZz3FU80RL1yoq4V+081QSGXYRrL4r1i7xX0zb5KbvzrAkxwJMR+FTWzsx049Zx92eaPh6rRYjSLHA2R91i733ZRMH5AJCKCuOFxb9yYGgONSo7jda04eJob/zobExyJMLR3YOMRW3mFHUR775q4ECRFBcJotuKHIm7dQNRT9vLKLdzQt9cC1UpMHRIDAPh6Hxc5OBsTHIlYX1QNk9mK5KhApOg4ya+3ZDIZZnRONv6ykGUqop44rG/GkeoW+CnkuOkandjheCX7Bena/VWwsheXUzHBkQj7MPEvhsdxa4YrNGOk7USzrawOtc1GkaMh8nzfdI7eTBkcBa2/SuRovNOUwVEI1ihR1dSO3SfPiB2OpDDBkYDGNhO2lNYBgGOyLPVeYmQgRsSHwmIV8N2BKrHDIfJogiCcK0+xLH7F1EoFsjtHv1imci4mOBKwrkgPs1VAii6YPSiu0ozOEzWb/hFd2v5TTShvaIO/SoGpQ6LFDser2RPE7w7o0WGxihyNdDDBkYC1+22jDbyKunq/GB4LuczWEZo7jBNdnL08lZkagwA/NhW9GuOSIxAZ5IeGVhO2ldWJHY5kMMHxcnUtRscfxC+4iuGqRYdoMC7ZtlHgN/s52ZioO1ar4Liw4qrNq6dUyB09hNj0z3mY4Hi57w/qYRWAYX206BcRKHY4kmCfx8R5OETd23WiAXpDO4I1SkwaxJ3DncGeKP5QVI32Dm4Z4wxMcLycfWsGjt44z42pOig694g5Wd8qdjhEHsc+upl9jQ5qpULkaKRhdEIY+oT6o8VodmxcSleHCY4Xqza0I/9EAwBgOhMcpwkP9MN1SeEAbCNkRHSO2WLFdwdsfxe3jmR5ylnkchl+YR895nnHKZjgeLHvDlRBEIDRCaHoGxYgdjiScvNQ24mGCQ5RVzuPNaCh1YTwQD9kJHHPO2eyn3d+KmaZyhmY4Hixb/ada+5HzpV1jQ4yGbCvohGnG8+KHQ6Rx8gpss1Ny7omBkoFv0KcaXgfLWK1GrSaLNhaytVUV4u/nV6qquks9pQ3QiZjecoVooLVuDbRVqbK4SgOEQDb6ql1RdUAbBcB5FxyuczxuXL0+OoxwfFSP3SeZNISwhATohE5GmmaNrTzRMPVVEQAgD3lZ1DbbESwRulop0DOdXPneefH4mo2/btKTHC8lH1UgVdRrpPdWQ/fffIMqg3tIkdDJD77eSdzSAz8lPz6cIUxieGIDPJD09kO7DxWL3Y4Xo2/oV6oodXkWD3FBMd1dFoNRieEArBth0HkywRBQE4RL6xcTSGX4cZUlqmcgQmOF/qxuBoWq4AhsSFIiODqKVeydxdl0z/ydUWVBpw6cxYalRyTB0WJHY6k2ctUPxTpYbEKIkfjvZjgeKEfOq+isnkV5XL2K9X84w2oazGKHA2ReOzlqSmDouHvx+Z+rpSRHIEQjRJ1LSYUnDwjdjheiwmOl2k1mrG5c/lg1tAYkaORvvjwAAzvq4VVODexm8gX2ctTNw/jhZWrqRRyZKbazu/fH+To8ZVyS4KzYsUKJCYmQqPRID09Hfn5+Rc99r333oNMJuty02i6rhISBAHLli1DbGws/P39kZmZidLSUle/DY+w8XAtTGYrEiMCMDgmWOxwfEK2fTUVTzTko8pqmlFW0wKVQobrU6LFDscn2Jv+rTuohyCwTHUlXJ7gfPbZZ1iyZAmeeuop7NmzByNGjEBWVhZqai6+10ZISAiqqqoct5MnT3b5+YsvvohXX30VK1euRF5eHgIDA5GVlYX2dumvdFl33iQ/mUwmcjS+wX6i2X60Ho1tJpGjIXI/e3lq/IBIhGhUIkfjGyYOjESAnwKVTe3Yd6pJ7HC8kssTnFdeeQULFizAvHnzkJqaipUrVyIgIACrV6++6GNkMhl0Op3jFhNzrhQjCAL+8Y9/4M9//jNmzJiB4cOH44MPPkBlZSW+/PJLV78dURnNFvzUuQlb1lAOE7tL/8hApOiCYbEK2HCYm+CR73GUp3jecRuNSuEYLWOz0Svj0gTHZDKhoKAAmZmZ515QLkdmZiZ27Nhx0ce1tLSgX79+iI+Px4wZM1BUVOT42fHjx6HX67s8p1arRXp6+kWf02g0wmAwdLl5o+1H69FiNCM6WI2RfUPFDsenZA6xJdnrD3EeDvmWioY2HDxtgFx27u+A3MOeUOYcrGKZ6gq4NMGpq6uDxWLpMgIDADExMdDru89IBw8ejNWrV+Orr77Chx9+CKvVinHjxuHUqVMA4Hhcb55z+fLl0Gq1jlt8fPzVvjVR/HBeeUouZ3nKnW7snPC36XAtjGZugke+w14WH9s/HBFBapGj8S3XD46Gn1KOE/VtKK1pETscr+Nxq6gyMjIwZ84cjBw5EpMnT8Z///tfREVF4c0337zi51y6dCmampoct4qKCidG7B4Wq+BYxcMmW+43rI8WMSFqtJos2HGU3UXJd9jPO2xL4X6BaiXGJ9t2bOfoce+5NMGJjIyEQqFAdXXX/zHV1dXQ6Xr2x6JSqTBq1CiUlZUBgONxvXlOtVqNkJCQLjdvU3DyDOpbTdD6q5CeFC52OD5HLpexTEU+p6HVhN0nbV3T7cuWyb3sn/uPxTzv9JZLExw/Pz+kpaUhNzfXcZ/VakVubi4yMjJ69BwWiwUHDhxAbKxtJUv//v2h0+m6PKfBYEBeXl6Pn9Mb2YeJpw6JhkrhcQNvPuHG8040VnYXJR+woaQGVgEYEhuCvmHsmi4G+4VVYUUjapqlv1LYmVz+TblkyRK8/fbbeP/991FcXIz7778fra2tmDdvHgBgzpw5WLp0qeP4p59+Gj/88AOOHTuGPXv24O6778bJkyfxu9/9DoBthdXixYvx7LPP4uuvv8aBAwcwZ84cxMXFYebMma5+O6IQBMGRvd+UymFisWQkRyDQT4FqgxEHTnPZJklfbontvHPjEPa+EUtMiAYj+mohCLaEk3pO6eoXuOuuu1BbW4tly5ZBr9dj5MiRyMnJcUwSLi8vh1x+Ls86c+YMFixYAL1ej7CwMKSlpWH79u1ITU11HPPYY4+htbUVCxcuRGNjIyZMmICcnJwLGgJKxdHaFpysb4OfQo6JAyPFDsdnqZUKTB4che8O6LH+UDVGxIeKHRKRyxjNFmw6XAuA5SmxZQ6Jwb5TTVh/qAZ3XZsgdjheQyb44Nozg8EArVaLpqYmr5iPs3LTUfzt+xJMHhSF9387VuxwfNqavafw8Gf7kKILRs7iSWKHQ+Qym47U4t7V+YgOVmPn0qlcuSmi4ioDbv6/LdCo5Nj75E0+vRdYb76/OZnDC+R2lqcyOUwsuusHR0Mhl6FE34yKhjaxwyFymR87J9NPHRLD5EZkKbpg9An1R3uHFdvK6sQOx2swwfFwDa3ndpO9gU22RBca4IdrE8MAAD9wNRVJlCAIjgurG1N5YSU2mUzWZZED9QwTHA93/iqGPqH+YodDAG7snOi9/hDbp5M0HaoyoLKpHf4qBcYlc96fJ7CvpvqxuIarOHuICY6Hs69iYHnKc9zUeSW168QZbr5JkvTjIdtqnQkDI6FR+e58D08ytn84gtVK1LUYse9Uo9jheAUmOB7MZLZi8xFbvXUqy1MeIz48gJtvkqSdWx7O846n8FPKMXlwFACWqXqKCY4Hyztu21wzKliN4X20YodD52FXY5IqfVM79p9qgkwGx27W5Bkc83AO8cKqJ5jgeLDcYtsv8dSUaK5i8DBTO0uGW47UocNiFTkaIuexj96MjA9FVDA31/QkUwbZVnEerm5GeT1XcV4OExwPdX73YpanPM+IvqGICPRDs9GMXScaxA6HyGnsy8Mzed7xONoAFcYm2vYiXM8y1WUxwfFQR6pbcOrMWaiVckwYwFUMnkYulznq4WyfTlLRZjJj29F6AOfKIeRZ7KPHP5UwwbkcJjgeyj56M35ApE93rfRkN6TYTzRMcEgatpbWwWS2Ij7cHwOjg8QOh7phP+/kH29Ai9EscjSejQmOh8p1lKc4yc9TTRwYBYVchqO1rayHkyRs6Nx7ampKDGQyzvvzRElRQUiMCECHRcDWUnY1vhQmOB6orsWIvRWNAGwnGvJMWn8VxvSzdTXmcDF5O0EQsLGz7cGUzvIreSb76jaWxy+NCY4H2nS4FoIAXBMXAp1WmjukS4WjTNV55UvkrUr0zahqaodGJcd1SRFih0OXcP3gzgTncA18cL/sHmOC44E2HrF9Wd7AHhQez/7/aOexerSZWA8n72VvWjk+md2LPV16Ujj8VQrUNBtRVGkQOxyPxQTHw5gtVmzuTHCmDGaC4+kGRAchPtwfJrMV28rqxQ6H6IrZyx1TeGHl8dRKBcZ3rq7dyG7qF8UEx8MUVjSi6WwHQgNUGBkfKnY4dBkymQw3DOZqKvJuTW0dKDh5BgBwPeffeAWu4rw8Jjgexj5MPKlzhQ55PvuEv42sh5OX2lRaC6sADIoJQt+wALHDoR6wTwTfW9GIhlZu+tsdJjgeZkOJrTx1fQqvorzFdUkR8FcpUNXUjuKqZrHDIeq1jZ2jANezLO414kL9kaILhiDAMa2BumKC40H0Te04VGWATGYbwSHvoFEpMH6AbdUJdxcnb2O1Co6FDdxc07uwTHVpTHA8yKYjtl/SEX1DERHETe68yfU80ZCX2nfKVuIIViuR1tnXibyD/byz6UgtLFaWx3+OCY4HcZSnOEzsdez/z/aWn2E9nLyKvXvxxEGRUCn4leBNRsWHQuuvQtPZDuwtPyN2OB6Hv80ewmS2YmuZre025994H3s93CoAW0pZDyfvsYHzb7yWUiHHpEG27wuOHl+ICY6H2H3StnFaZJAfhsZpxQ6HroC9b9EmdjUmL1HT3I4Dp5sAAJO5PNwr3dB5QbyB550LMMHxEBs7fzknD4qGnMvDvdLkziupTUdqYWU9nLyAPRkf1keL6GBuC+ONJg2MgkwGFFcZUNV0VuxwPAoTHA/h6CLKqyivldYvDEFqJepbTWyfTl7BvuqPq6e8V0SQGiP6hgLgcvGfY4LjAU6daUNpTQvkXB7u1fyUcoxLti0XZ/t08nRmixVbSm3z/nhh5d3OHz2mc5jgeAB7eSqtXxi0ASqRo6Gr4ZiHwxMNebjCikY0t5sRGqByjACQd7InqFtK62C2WEWOxnMwwfEA9qt9bq7p/SYNsm2At6f8DJraOkSOhuji7En4RG4L4/WG9w1FaIAKze1mFFY0ih2Ox2CCIzKj2YLtR227UNuHGcl79Q0LwIDoIFgFOJb9E3kie4LD8473U8hlmDiQZaqfY4IjsoITZ9BmsiAqWI1r4kLEDoecYErnFwbn4ZCnqmsxYv8p2/LwSQMjRY6GnIHzcC7EBEdkm0rtw8SRkMk4TCwF9n4im47Ucndx8khbOycXp8aGIDqEy8OlwJ6o7j/VhLoWo8jReAa3JDgrVqxAYmIiNBoN0tPTkZ+ff9Fj3377bUycOBFhYWEICwtDZmbmBcfPnTsXMpmsyy07O9vVb8MlNh3mMLHUXJsYDn+VAjXNRu4uTh7JUZ7i6inJiA7RIDXWVgWwJ7C+zuUJzmeffYYlS5bgqaeewp49ezBixAhkZWWhpqb74fuNGzfi17/+NTZs2IAdO3YgPj4eN910E06fPt3luOzsbFRVVTlun3zyiavfitNVG9pRom+GTAZH/ZS8n0alQEbncnEOF5OnsVoFR78UtqWQlvNHj8kNCc4rr7yCBQsWYN68eUhNTcXKlSsREBCA1atXd3v8Rx99hAceeAAjR45ESkoK3nnnHVitVuTm5nY5Tq1WQ6fTOW5hYd63C679JDO8jxbhgX4iR0POZF+2yXk45GmKKg2obzUh0E/B3cMlxl4J2Mxu6gBcnOCYTCYUFBQgMzPz3AvK5cjMzMSOHTt69BxtbW3o6OhAeHh4l/s3btyI6OhoDB48GPfffz/q6+sv+hxGoxEGg6HLzRNwFYN02f+fFpw8g+Z2Lhcnz7HpiC3pHjcgEn5KTsOUktEJ57qpH6xsEjsc0bn0t7uurg4WiwUxMTFd7o+JiYFer+/Rczz++OOIi4vrkiRlZ2fjgw8+QG5uLl544QVs2rQJN998MywWS7fPsXz5cmi1WsctPj7+yt+Uk1isgmMZMevg0tMvIhD9IwNhtgrYVnbx5JvI3XhhJV3nd1Pnpr8evorqb3/7Gz799FOsWbMGGs25mf6zZs3CrbfeimHDhmHmzJlYu3Ytdu3ahY0bN3b7PEuXLkVTU5PjVlFR4aZ3cHH7TzWisa0DwRolu4hK1LllmyxTkWcwtHdgT3kjACY4UsV5OOe4NMGJjIyEQqFAdXV1l/urq6uh0+ku+diXX34Zf/vb3/DDDz9g+PDhlzw2KSkJkZGRKCsr6/bnarUaISEhXW5iO9dFNBJKhUfnmXSFztXD67hcnDzC9rI6WKwCkqICER8eIHY45AL28w67qbs4wfHz80NaWlqXCcL2CcMZGRkXfdyLL76IZ555Bjk5ORgzZsxlX+fUqVOor69HbGysU+J2h80cJpa89KRw+CnkON14FsfqWsUOh4jlKR9wfjf1bUd9e7m4y4cOlixZgrfffhvvv/8+iouLcf/996O1tRXz5s0DAMyZMwdLly51HP/CCy/gySefxOrVq5GYmAi9Xg+9Xo+WlhYAQEtLCx599FHs3LkTJ06cQG5uLmbMmIEBAwYgKyvL1W/HKZraOhz7hUziiUayAvyUuLa/bZXKZg4Xk8gEQWDfLR8xmd3UAbghwbnrrrvw8ssvY9myZRg5ciQKCwuRk5PjmHhcXl6Oqqoqx/FvvPEGTCYTfvWrXyE2NtZxe/nllwEACoUC+/fvx6233opBgwZh/vz5SEtLw5YtW6BWq139dpxia1kdrAIwKCYIsVp/scMhF7L3GWGCQ2Irq2lBZVM71Eo5rkuKEDscciH7hfOWUt8ujyvd8SKLFi3CokWLuv3ZzycGnzhx4pLP5e/vj3Xr1jkpMnHYJ53yKkr6Jg6MwvLvS7DzWAOMZgvUSoXYIZGPspenxvYPh0bF30MpS+8fDj+lHFVN7SiracHAmGCxQxIFZ7e6mSAIjhMNy1PSNyQ2GFHBapztsKDgxBmxwyEftrmzfT8vrKRPo1Igvb+td9xmH962gQmOmx2pbkG1wQiNSo5rE8Mv/wDyajKZDBM7N8Gzb6xK5G7tHRbkHbP1Y+KFlW9geZwJjtvZf9muS4rgMLGPOH+5OJEYdp1ogNFsRUyIGgOjg8QOh9xg4iDbhVXe8Xq0d3TfBFfqmOC42eZSbnLna8YPsJ1oiqsMqGluFzka8kVbOssUEwdGQSaTiRwNucPgmGBEB6vR3mHFbh8tjzPBcaP2DgvyjzcAACZ1ZtckfZFBagztY2suudWH6+Ekns2c9+dzbOVx+2oq3yxTMcFxo/zjtmHiWK0GyVEcJvYlrIeTWGoM7SjRN0MmAyYM4IWVL7FfSPvqtg1McNzInkVPHBjJYWIfY7+S2lpWB6vVd/tSkPvZV9EM66NFeKCfyNGQO00YEAmZDCjRN6PG4HvlcSY4bnR+HZx8S1q/MAT6KVDXYsKhKoPY4ZAPOf/CinxLRJAaQ+O0AM59//gSJjhuwmFi3+anlCMj2dY9drOP1sPJ/axWwTHviwsbfJM9sfXFeThMcNzEPkw8vI8WYRwm9kmO9ulcLk5ucqjKgPpWEwL9FBiVECZ2OCSC87dt8LXyOBMcNzk3TMyrKF9l/3+/+2QDWo1mkaMhX2AfLcxIjoCfkqd7XzQ6wVYer2/1vfI4f+Pd4PxhYtbBfVdiRADiw/3RYRGws7OrLJErcXk4+XJ5nAmOG3CYmICf96VgmYpcq9VoRsFJW4M3jhz7tok+2qaCCY4bcJiY7Cb58IQ/cq+dx+rRYREQH+6PxIgAscMhEdlH8ApOnvGp8ji/bd3APqmUw8SUkRwJuQw4WtuKysazYodDEsbtGcguMSIAfcN8rzzOBMfF2kxm7D5p256Bw8Sk9VdhZHwoAG7bQK51bt87zvvzdb5aHmeC42J5xxrQYRHQN4zDxGQzwV4PZ5mKXOTUmTYcq22FQi5DRjITHPLN8jgTHBez7wHCYWKys59otpbVweJjfSnIPeyjgyP6aqH1V4kcDXmCcT5YHmeC42Jsk04/NyI+FMFqJRrbOlBU2SR2OCRBW8q4LQx1pQ1QYXjfUAC+Ux5nguNClY1ncbS2FXIZMJ7DxNRJpZDjus6+FL5UDyf3sFgFbCtj3y26kKNMVeYb5x0mOC5kz5KH9w2FNoDDxHSOL9bDyT2KKpvQ2NaBYLUSIzontBMB5+b/bS2t9YltG5jguJA9S+YqBvo5e+nA1/pSkOvZRwWvS46ASsFTPJ0zKiEUgX4KnGnrQFGl9Ldt4G+/i1jPGyaewDo4/Uy/87ZtyD/eIHY4JCFbuDycLkKlkDtW1W0pk/7oMRMcFzlUZUCDY3uGULHDIQ8jk8kwYQCXi5NzcXsGuhz7vCx7A1opY4LjIudvz8BhYurOuXk40j/RkHvkHa939N3qx75b1A17glNw8gzaTNIuj/Ob10W2lnKZJl2avS9FWU0Lqpp8oy8FuRa3Z6DL6R8ZiD6h/jBZrMiTeHmcCY4LnDVZsPuEbZh4AuvgdBHaAJVjlQtHccgZziU4PO9Q92zbNvhGmYoJjgvkHa+HyWJFn1B/JEUGih0OebCJA1imIueoajqLspoWyGXAuM4+S0TdsVcWtkp8ojETHBewf1lNGBDJYWK6pImdO8xvK6vzib4U5Dpbzuu7FRrgJ3I05MnGJUdAJgOOVLdA39QudjguwwTHBRzzbwZxmJgubWR8KILUSjS0mnCoSvp9Kch1trI8RT0UFuiH4X20AGx74kkVExwnqza043B1M2TcnoF6QKWQ47okbttAV8dqFRxfVFzYQD1h/z2Rcjd1tyQ4K1asQGJiIjQaDdLT05Gfn3/J47/44gukpKRAo9Fg2LBh+O6777r8XBAELFu2DLGxsfD390dmZiZKS0td+RZ6zH4VNayPFmGBHCamy5vIbRvoKrHvFvWWfQHM1lLplsddnuB89tlnWLJkCZ566ins2bMHI0aMQFZWFmpqaro9fvv27fj1r3+N+fPnY+/evZg5cyZmzpyJgwcPOo558cUX8eqrr2LlypXIy8tDYGAgsrKy0N4ufi3R/iU1YQBHb6hn7AnO7hNncNZkETka8kaO7RmS2HeLemZ0QhgC/BSobzWhWC/N8rjL/xJeeeUVLFiwAPPmzUNqaipWrlyJgIAArF69utvj/+///g/Z2dl49NFHMWTIEDzzzDMYPXo0Xn/9dQC20Zt//OMf+POf/4wZM2Zg+PDh+OCDD1BZWYkvv/zS1W/nkmzDxPUAOExMPde1L0W92OGQF7JfWHH+DfWUn1L65XGXJjgmkwkFBQXIzMw894JyOTIzM7Fjx45uH7Njx44uxwNAVlaW4/jjx49Dr9d3OUar1SI9Pf2iz2k0GmEwGLrcXKFE34y6FiP8VQqM7hfqktcg6bFt23BuuJioN87vu2VflUfUE1I/77g0wamrq4PFYkFMTEyX+2NiYqDX67t9jF6vv+Tx9v/25jmXL18OrVbruMXHx1/R+7kce0+B65LCoVYqXPIaJE32FXdSXtFArpF/ogEmixVxWg37blGvTOo87+SfaEB7h/TK4z5RrF26dCmampoct4qKCpe8zpTB0Vhy4yDcOcY1CRRJ1/jkSMhktlHAGoP4c8nIe2w5Yi9PcXsG6p3kqCDoQjQwma3Il+C2DS5NcCIjI6FQKFBdXd3l/urqauh0um4fo9PpLnm8/b+9eU61Wo2QkJAuN1cYFBOMP0wdiJuHxbrk+Um6wgL9MMwH+lKQ89l/X7gtDPXW+ds2SPG849IEx8/PD2lpacjNzXXcZ7VakZubi4yMjG4fk5GR0eV4AFi/fr3j+P79+0On03U5xmAwIC8v76LPSeQNJnDbBuqlGkM7SvSdfbe4cpOugD0x3nxEem0qXF6iWrJkCd5++228//77KC4uxv3334/W1lbMmzcPADBnzhwsXbrUcfxDDz2EnJwc/P3vf0dJSQn+8pe/YPfu3Vi0aBEAW8a5ePFiPPvss/j6669x4MABzJkzB3FxcZg5c6ar3w6Ry5zbH6YOgiDNvhTkXPar7qFxWoSz7xZdAfuFVYm+GTXN0iqPK139AnfddRdqa2uxbNky6PV6jBw5Ejk5OY5JwuXl5ZDLz+VZ48aNw8cff4w///nP+OMf/4iBAwfiyy+/xNChQx3HPPbYY2htbcXChQvR2NiICRMmICcnBxqNxtVvh8hlRvcLhb9KgdpmIw5XNyNF55pSKkmHY987lqfoCkUEqXFNXAiKKg3YVlaHX47qK3ZITiMTfPBS0WAwQKvVoqmpyWXzcYiuxNx387HxcC3+NG0IFkxKEjsc8mCCIODa53JR12LExwvSMY5bw9AVWv59Md7cdAy3je6DV+4cKXY4l9Sb72+fWEVF5C0c+8NIcMIfOdf5fbfS+oWJHQ55sUn28niptMrjTHCIPIh9RUPesXpJ9qUg57E3Z0tn3y26Smn9wqBWylHTbMSR6haxw3EaJjhEHmRgdBBiQtQwmq2O7rRE3dnMfe/ISTQqBdId2zZIZzUVExwiD2LbtsFeppLOiYacq73D4mjMNonbM5ATTJRgmwomOEQext4+Xar7w9DV233iDIxmK2JC1BgYHSR2OCQB9u1i8o7Xw2iWRnmcCQ6Rh7E3bCuqNKCuxShyNOSJ7KN7EwZwewZyjsExwYgKVqO9w4oCiZTHmeAQeZjIzr4UALCNq6moG1uO2H4vJrL/DTmJTCY7V6aSyHmHCQ6RBzrXPl0aJxpynroWIw5VGQBwewZyLnuZSioTjZngEHkge1+KLaW1kupLQVfPPqqXGhuCqGC1yNGQlNgT5oOnDaiXQHmcCQ6RB0rrFwaNSnp9Kejq2Uf17FfbRM4SHazBkFhbeVwKu4szwSHyQBqVAun9pdeXgq6OIAiO3wf7KB+RM00aKJ3l4kxwiDzURAmdaMg5jlS3oKbZCI1Kzu0ZyCUmSqg8zgSHyEPZTzR5x7ltA9nYR2/S+0dAo+L2DOR8YxJt2zZUG4worfHu8jgTHCIPNSgmCNH2vhQnpdGXgq7O5lIuDyfXOn/bhs1HvLs8zgSHyEPJZDLHKM5mzsPxee0dFuQdqwfA7RnItaSybQMTHCIPZt+2YQv74fg8bs9A7nL+tg3eXB5ngkPkwex9KQ5VGVDb7P19KejK2effTBzI7RnItc7ftmGPF5fHmeAQebDzt23YfpSjOL6M82/IXWzl8c5u6l5cpmKCQ+ThuG0D1TS3o7hze4YJ3J6B3OD8bureigkOkYfjtg1k355haJ8QRARxewZyPXt5vKjSgDov3baBCQ6Rhzt/24bD1c1ih0MiOLd7OFdPkXtEBauR2rltwzYv3baBCQ6Rh9OoFLhOIn0pqPcEQeD8GxKFfTWVt5bHmeAQeQF7mcpbTzR05Ur0zahrMcJfpeD2DORW3l4eZ4JD5AXsjd3yTzTgrMl7+1JQ79kneV6XFA61ktszkPuMSTxXHi/Re195nAkOkRdIjgpEn1B/mMxW7DxeL3Y45EabOf+GRKJWKpDhxeVxJjhEXkAmkzm6GnvjiYauTJvJjPzjDQC4PQOJw/57543bxTDBIfISjn2pmOD4jLxjDTBZrOgT6o/kqECxwyEfZE9wdh0/gzaTWeRoeocJDpGXGJ8cCbkMOFrbitONZ8UOh9xgU2cyO2kQt2cgcSRFdpbHLVbsPOZd5XEmOEReQhugwsj4UAAcxfEV9v/PkwdxeTiJQyaTYfJg71zFyQSHyIs46uFMcCSvoqENx+paoZDLMI7bM5CIJnlpeZwJDpEXsSc4W8vqYLZYRY6GXMk+qXN0QihCNCqRoyFfNm5ABBRyGY7VtaKioU3scHrMpQlOQ0MDZs+ejZCQEISGhmL+/PloaWm55PG///3vMXjwYPj7+yMhIQF/+MMf0NTU1OU4mUx2we3TTz915Vsh8ggj+oZC669Cc7sZ+041ih0OudCmw/byFFdPkbhCNCqMTggFcG5emDdwaYIze/ZsFBUVYf369Vi7di02b96MhQsXXvT4yspKVFZW4uWXX8bBgwfx3nvvIScnB/Pnz7/g2HfffRdVVVWO28yZM134Tog8g0Iuc+wmvcnL6uHUcx0WK7YftU3o5PJw8gSTvbA87rIEp7i4GDk5OXjnnXeQnp6OCRMm4LXXXsOnn36KysrKbh8zdOhQ/Oc//8Ett9yC5ORk3HDDDXjuuefwzTffwGzuujwtNDQUOp3OcdNoNK56K0Qehf1wpG/PyTNoMZoRHuiHoXFascMhciTa24/Wo8NLyuMuS3B27NiB0NBQjBkzxnFfZmYm5HI58vLyevw8TU1NCAkJgVKp7HL/gw8+iMjISIwdOxarV6++5D4ZRqMRBoOhy43IW9lPNPtPNaKxzSRyNOQK9vk3EwdGQi7n8nAS39A4LcID/dBiNGNveaPY4fSIyxIcvV6P6OjoLvcplUqEh4dDr9f36Dnq6urwzDPPXFDWevrpp/H5559j/fr1uP322/HAAw/gtddeu+jzLF++HFqt1nGLj4/v/Rsi8hCxWn8MjA6CVbBNNibpsS/HncTtGchDyLuUx2tEjqZnep3gPPHEE91O8j3/VlJSctWBGQwGTJ8+HampqfjLX/7S5WdPPvkkxo8fj1GjRuHxxx/HY489hpdeeumiz7V06VI0NTU5bhUVFVcdH5GY7KM49omoJB11LUYcOG1bWDGR/W/Ig5ybh+MdF1bKyx/S1SOPPIK5c+de8pikpCTodDrU1HTN8sxmMxoaGqDT6S75+ObmZmRnZyM4OBhr1qyBSnXpJZLp6el45plnYDQaoVarL/i5Wq3u9n4ibzV5UBRWbT2OzaW1EASBXW4lZGup7csjNTYE0cGcW0iew55wH6xsQn2LERFBnv292usEJyoqClFRlx82zcjIQGNjIwoKCpCWlgYA+Omnn2C1WpGenn7RxxkMBmRlZUGtVuPrr7/u0eThwsJChIWFMYkhnzG2fzj8VQpUG4wormpGalyI2CGRk2w+b3sGIk8SHazBkNgQFFcZsKW0DjNH9RE7pEty2RycIUOGIDs7GwsWLEB+fj62bduGRYsWYdasWYiLiwMAnD59GikpKcjPzwdgS25uuukmtLa2YtWqVTAYDNDr9dDr9bBYLACAb775Bu+88w4OHjyIsrIyvPHGG3j++efx+9//3lVvhcjjaFQKZCRHAAA2ekk9nC7PahUcE4zZ/4Y8kf330hv64bi0D85HH32ElJQUTJ06FdOmTcOECRPw1ltvOX7e0dGBw4cPo63N1hlxz549yMvLw4EDBzBgwADExsY6bvZ5MyqVCitWrEBGRgZGjhyJN998E6+88gqeeuopV74VIo8zpXN/mI2chyMZh6oMqGsxIcBPgbR+YWKHQ3SBKYPP9cOxWi++etkT9LpE1Rvh4eH4+OOPL/rzxMTELsu7p0yZcsnl3gCQnZ2N7Oxsp8VI5K2mDIoGUISCk2dgaO9gO38J2HjYNho3fkAk/JTcSYc8T1q/MASrlahvNeHA6SaM6NwA2BPxL4jISyVEBCApMhAWq4DtXC4uCRs6R+OuHxx9mSOJxKFSyDG+c7m4p48eM8Eh8mKTWaaSjMY2E/aWnwFwrgxA5Insv58bDnv2/D8mOERebErnlf7Gw7WXLe+SZ9tcWgerAAyKCUJcqL/Y4RBdlP28s+9UIxpaPbebOhMcIi+W3j8caqUcekM7Dlc3ix0OXQX7/BuWp8jT6bQapOiCIQjAllLPHT1mgkPkxbosF2eZymtZrYKj/81klqfIC5w/euypmOAQebkp3LbB6x2sbEJdiwlBaiXG9AsXOxyiy7LPw9nkwcvFmeAQeTn7ldTukw1oMZpFjoauhP0qePyACC4PJ69gXy7e0GrC/s690zwN/5KIvFxiZCASIwLQYRGwjcvFvZJ9NcoUzr8hL6FSyDFhoH25uGeupmKCQyQB3lAPp+41tJpQWNEIgMvDybt4ejd1JjhEEmCfmLrpcA2Xi3uZLaW1EAQgRReMWC2Xh5P3mDzIs5eLM8EhkoCMpAiolXJUNrXjSHWL2OFQL9ivflmeIm9z/nLxzR64+SYTHCIJ0KgUGNe5XPynEs+sh9OFrFbBsSszy1Pkja5PsZfHPe+8wwSHSCJuGBIDAPippFrkSKin9p9uQkOrCcFqJXcPJ69kb1OxubQOFg9bLs4Eh0gibui8kio4eQaNbZ5XD6cL2a96JwyMhErB0zF5n9H9whCssS0X33eqUexwuuBfFJFE9An1R4ouGFYBjrIHebYNJfbl4SxPkXdSKeSY3DmKk1vsWaPHTHCIJMQ+ipNb7Hn1cOqqxtCOfadsDdLs8xiIvNHUIZ553mGCQyQh9gRn05FamC1WkaOhS7E39xvRV4voYI3I0RBduSmDoiGXASX6ZpxuPCt2OA5McIgkZFRCGEIDVGg624E95Y1ih0OX8GPn1e7UzsnhRN4qLNDPMUnek1ZxMsEhkhCFXOZY1ZDL1VQeq73Dgq2ltm01bmB5iiTghhRbou5J83CY4BBJjH25+AYPupKirnYcq8fZDgt0IRpcExcidjhEV80+D2f70Xq0mTxj018mOEQSM3lgFBRyGY5Ut6CioU3scKgbP3WWp24YEg2ZTCZyNERXb2B0EPqG+cNktmJbWb3Y4QBggkMkOdoAlUfWw8lGEATHMP5UlqdIImQyGTI9rNkoExwiCbJ/cTLB8Twl+mZUNrVDo5Jj/IBIscMhcprz21R4wqa/THCIJMheD99xzHPq4WRjH70ZnxwJjUohcjREzpOeFI4APwVqmo04eNogdjhMcIikKDkqCPHhnlUPJ5vcEi4PJ2lSKxWYONA2KukJqziZ4BBJkEwmw1QPXLbp6+pajCisaATA5eEkTVMd83DEL48zwSGSKHuZ6sfiGlg9bJdfX7WhpAaCAAztEwKdlt2LSXquH2w77+w/1YQaQ7uosTDBIZKo9P4RCFYrUddixN7OUQMSl32vHntTNCKpiQpWY0R8KADxR3GY4BBJlJ9S7tjE8YdDepGjIaPZgi2ltl3eM4ewPEXSZV/FmcsEh4hc5cZU20jB+kOchyO2ncca0GqyICpYjaFxWrHDIXKZ6cNjsewXqfjz9CGixqEU9dWJyKWmDI6CSiHDsdpWlNW0YEB0kNgh+awfimyjaJlDYiCXs3sxSVdyVBCSo8Q/17h0BKehoQGzZ89GSEgIQkNDMX/+fLS0tFzyMVOmTIFMJutyu++++7ocU15ejunTpyMgIADR0dF49NFHYTaz1wfRzwVrVMhIti3b5CiOeKxWwfH5Z13D+TdE7uDSBGf27NkoKirC+vXrsXbtWmzevBkLFy687OMWLFiAqqoqx+3FF190/MxisWD69OkwmUzYvn073n//fbz33ntYtmyZK98Kkde6qbNMxXk44tlb0YiaZiOC1UqMS2b3YiJ3cFmCU1xcjJycHLzzzjtIT0/HhAkT8Nprr+HTTz9FZWXlJR8bEBAAnU7nuIWEnNtt94cffsChQ4fw4YcfYuTIkbj55pvxzDPPYMWKFTCZTK56O0Reyz4Pp7CiUfRlm77KnlxOSYmGn5JTH4ncwWV/aTt27EBoaCjGjBnjuC8zMxNyuRx5eXmXfOxHH32EyMhIDB06FEuXLkVb27kdkXfs2IFhw4YhJubcMG9WVhYMBgOKioq6fT6j0QiDwdDlRuQrYkI0GBEfCkGw9cQh9xIEAT8UsTxF5G4uS3D0ej2io7suhVQqlQgPD4def/Gh8t/85jf48MMPsWHDBixduhT/+te/cPfdd3d53vOTGwCOf1/seZcvXw6tVuu4xcfHX+nbIvJKNzlWU7FM5W6lNS04XtcKP4UcUwZzeTiRu/Q6wXniiScumAT881tJSckVB7Rw4UJkZWVh2LBhmD17Nj744AOsWbMGR48eveLnXLp0KZqamhy3ioqKK34uIm9kT3C2ldWjxcgJ+e5kXz01fkAEgtRcuErkLr3+a3vkkUcwd+7cSx6TlJQEnU6Hmpquw+FmsxkNDQ3Q6XQ9fr309HQAQFlZGZKTk6HT6ZCfn9/lmOpq2/DvxZ5XrVZDrVb3+DWJpGZAdBASIwJwor4Nm4/UYtqwWLFD8hnrHOWpnp/3iOjq9TrBiYqKQlRU1GWPy8jIQGNjIwoKCpCWlgYA+Omnn2C1Wh1JS08UFhYCAGJjYx3P+9xzz6GmpsZRAlu/fj1CQkKQmpray3dD5BtkMhluTI3B21uOY/2haiY4blLZeBYHTjdBJgMyUzn/hsidXDYHZ8iQIcjOzsaCBQuQn5+Pbdu2YdGiRZg1axbi4uIAAKdPn0ZKSopjRObo0aN45plnUFBQgBMnTuDrr7/GnDlzMGnSJAwfPhwAcNNNNyE1NRX33HMP9u3bh3Xr1uHPf/4zHnzwQY7SEF3CTZ0jCLnF1eiwWEWOxjfYy1Nj+oUhMojnJyJ3cul6xY8++ggpKSmYOnUqpk2bhgkTJuCtt95y/LyjowOHDx92rJLy8/PDjz/+iJtuugkpKSl45JFHcPvtt+Obb75xPEahUGDt2rVQKBTIyMjA3XffjTlz5uDpp5925Vsh8nqjE8IQEegHQ7sZO4/Vix2OT2B5ikg8MkEQBLGDcDeDwQCtVoumpqYuPXaIpG7pf/fjk/wK/HpsApbfNkzscCTtTKsJY577ERargM2PXo+EiACxQyLyer35/mbHKSIfYp9780ORHmaWqVwqt6QGFquAFF0wkxsiETDBIfIh1yVFICxAhfpWE/KPN4gdjqSt65x/w/IUkTiY4BD5EJVCjptSbV+43x2sEjka6Wpu78CmI7UAgOyhTHCIxMAEh8jHTBtuK1PlHKyGxepzU/DcIre4BiazFUlRgUjRBYsdDpFPYoJD5GPGJUdA669CXYuRZSoXWbvfNjr2i2GxkMlkIkdD5JuY4BD5GFuZytZ07nuWqZzO0N6BzZ3lqenD40SOhsh3McEh8kH2MtX3B/UsUznZj4eqYbJYMSA6CINigsQOh8hnMcEh8kHjkyMRolGittmIgpNnxA5HUr61l6eGszxFJCYmOEQ+yE8px4321VQHWKZylqazHdhc2lme4n5fRKJigkPko6YNsyU43x+sgpVlKqdYf6gaHRYBg2OCMTCGq6eIxMQEh8hHTRgYiWC1EtUGI/aUs0zlDN/urwQATB/O0RsisTHBIfJRaqUCN3aupvqWZaqr1tTWgS2ldQDObYlBROJhgkPkw+xfxN/ur+Jqqqu07pAe5s69pwZEc/UUkdiY4BD5sEmDohAaoEJNsxE7j9WLHY5XW3ve6ikiEh8THCIf5qeUO0Zx1uw9LXI03utMqwnbylieIvIkTHCIfNwvR/UBAOQc1KO9wyJyNN7pu4O2El9qbAiSolieIvIETHCIfFxaQhj6hPqjxWjGj8XVYofjldbssY1+zRzFrRmIPAUTHCIfJ5fLMGOk7Yv5y72VIkfjfU7Wt2L3yTOQy4AZI/uIHQ4RdWKCQ0SOMtXGwzU402oSORrvYp+7NH5AJGJCNCJHQ0R2THCICANjgpEaGwKzVWBPnF4QBMGR4Nw2mqM3RJ6ECQ4RATg3ivMlV1P12J7yRpysb0OAnwJZ1+jEDoeIzsMEh4gAALeMiINMBuw+eQYVDW1ih+MV/rvnFAAge6gOAX5KkaMhovMxwSEiAIBOq0FGUgQA4KtCjuJcjtFscTT3u21UX5GjIaKfY4JDRA4z7WWqwkoIArduuJQNJbVoOtuBmBA1MpIjxA6HiH6GCQ4ROWQP1cFPKUdZTQuKKg1ih+PR7OWpmaP6QCGXiRwNEf0cExwicgjRqBw7jH++u0LkaDzXmVYTNhyuAcDyFJGnYoJDRF3MujYegK2/y1kTt27oztr9leiw2LZmGKwLFjscIuoGExwi6mJ8ciT6hvmjud2M7w+yJ053/rOHvW+IPB0THCLqQi6X4a4xtlGcT/NZpvq5Er0BhRWNUMpluHUk954i8lRMcIjoAneMiYdcBuSfaMDR2haxw/EoH+eVAwBuTI1BdDC3ZiDyVExwiOgCOq0G1w+OBgB8toujOHZtJrNj5/DZ6f1EjoaILsWlCU5DQwNmz56NkJAQhIaGYv78+WhpufjV4IkTJyCTybq9ffHFF47juvv5p59+6sq3QuRzZo1NAAD8p+AUTGaryNF4hm/2VaLZaEa/iACMY+8bIo/m0gRn9uzZKCoqwvr167F27Vps3rwZCxcuvOjx8fHxqKqq6nL761//iqCgINx8881djn333Xe7HDdz5kxXvhUin3P94ChEB6tR32rCj8XVYofjEezlqV+PTYCcvW+IPJrLNk8pLi5GTk4Odu3ahTFjxgAAXnvtNUybNg0vv/wy4uIunJynUCig03XdsG7NmjW48847ERQU1OX+0NDQC44lIudRKuS4Y0xfrNhwFJ/uqsC0YbFihySqg6ebsO9UE1QKGX6Vxt43RJ7OZSM4O3bsQGhoqCO5AYDMzEzI5XLk5eX16DkKCgpQWFiI+fPnX/CzBx98EJGRkRg7dixWr159ybbyRqMRBoOhy42ILu+uMbYy1ZbSWp/fgPPjfNvoTfbQWEQGqUWOhogux2UJjl6vR3R0dJf7lEolwsPDodfre/Qcq1atwpAhQzBu3Lgu9z/99NP4/PPPsX79etx+++144IEH8Nprr130eZYvXw6tVuu4xcfH9/4NEfmghIgAjB8QAUEAvig4JXY4omkxmvHVXtvk4t90zk0iIs/W6wTniSeeuOhEYPutpKTkqgM7e/YsPv74425Hb5588kmMHz8eo0aNwuOPP47HHnsML7300kWfa+nSpWhqanLcKiq4KoSop2Zda/tC/2xXOTosvjnZ+KvC02g1WZAUFYjrksLFDoeIeqDXc3AeeeQRzJ0795LHJCUlQafToaampsv9ZrMZDQ0NPZo78+9//xttbW2YM2fOZY9NT0/HM888A6PRCLX6wqFjtVrd7f1EdHlZ1+gQFaxGtcGI7w5UYcZI3+reKwiCY3Lxb8YmQCbj5GIib9DrBCcqKgpRUVGXPS4jIwONjY0oKChAWloaAOCnn36C1WpFenr6ZR+/atUq3HrrrT16rcLCQoSFhTGJIXIBP6Ucc67rh7+vP4JVW4/j1hFxPvUlv/9UE4oqDfBTynH7aE4uJvIWLpuDM2TIEGRnZ2PBggXIz8/Htm3bsGjRIsyaNcuxgur06dNISUlBfn5+l8eWlZVh8+bN+N3vfnfB837zzTd45513cPDgQZSVleGNN97A888/j9///veueitEPu836QlQK+XYf6oJu0+eETsct3p323EAwPRhsQgL9BM5GiLqKZf2wfnoo4+QkpKCqVOnYtq0aZgwYQLeeustx887Ojpw+PBhtLV1XZ2xevVq9O3bFzfddNMFz6lSqbBixQpkZGRg5MiRePPNN/HKK6/gqaeecuVbIfJpEUFq/HKUrTS1astxkaNxn9ONZ/HNftuGo/Mn9Bc5GiLqDZlwqfXVEmUwGKDVatHU1ISQkBCxwyHyCkeqm3HT/9sMuQzY9Oj1iA8PEDskl3tm7SGs2noc45Ij8PGC68QOh8jn9eb7m3tREVGPDIoJxsSBkbAKwLvbTogdjss1ne3Ap529bxZOShI5GiLqLSY4RNRj9jLN57sr0NzeIXI0rvVxXjlaTRYMjgnG5EGXX+xARJ6FCQ4R9djkQVEYEB2EFqMZn++WbuM/o9nimFy8YFKST60aI5IKJjhE1GMymQy/HW8bxXlv+3FYrNKcwvdVYSVqmo2ICVHj1hEX7ptHRJ6PCQ4R9cpto/sgLECFioazyDnYs21XvIkgCHh78zEAwLzx/eGn5GmSyBvxL5eIekWjUuCejEQAwKu5pbBKbBRn4+FalNa0IEitxG/Sue8UkbdigkNEvTZ/fH8Ea5Q4XN2M7w5WiR2OU725+SgA4Ndj4xGiUYkcDRFdKSY4RNRr2gAVfjfBtnT6Hz+WSmYuzo6j9dh5rAFKuQzzxrOxH5E3Y4JDRFdk3oREaP1VKKtpwdr9lWKHc9UEQcCL60oAAL8em4C4UH+RIyKiq8EEh4iuSIhG5WiA948fS2G2WEWO6OqsP1SNveWN8Fcp8PsbBogdDhFdJSY4RHTF7h2XiLAAFY7XteLLQu8dxbFYBbz8w2EAwLzxiYgO0YgcERFdLSY4RHTFgtRK3Dc5GYBtRVWHl47ifLn3NI5Ut0Drr8L/dL4fIvJuTHCI6Krck9EPkUF+KG9ow3/3eF93Y6PZgv/34xEAwH2Tk6H158opIilggkNEVyXA7/xRnDKcNVlEjqh3Pskrx6kzZxEdrMbccYlih0NETsIEh4iu2t3X9UOcVoPTjWfxz41lYofTY61GM177yRbvQ5kD4e+nEDkiInIWJjhEdNU0KgWW3XINAODNTcdwtLZF5Ih65s1NR1HfakJiRADuHBMvdjhE5ERMcIjIKbKuicGUwVEwWax46qsiCIJnN/8rrW7GG5tsXYsfy06BSsHTIZGU8C+aiJxCJpPhr7deAz+lHFvL6vDtAc/dwsFqFfD4f/ajwyIgc0g0bh6qEzskInIyJjhE5DT9IgLxwBTbhONn1h5Ci9EsckTd+zDvJPaUNyLQT4GnZwyFTCYTOyQicjImOETkVPdNTka/iABUG4z4x/ojYodzgcrGs3gxx9bU7/GbU7glA5FEMcEhIqfSqBT46622Ccfvbj+BQ5UGkSM6RxAEPPnlQbQYzRidEIq70/uJHRIRuQgTHCJyuimDbfNaLFYBf/h0L1o9pFT17YEq5JbUQKWQ4YXbh0MuZ2mKSKqY4BCRSzwzcyiig9Uoq2nBn9YcEH1VVY2hHX/5uggA8OD1AzAwJljUeIjItZjgEJFLRAap8fpvRkMhl+HLwkp8lFcuWiztHRYs/FcB6lpMGBwTjPuncL8pIqljgkNELjO2fzgezx4MAHj6m0PYf6rR7TEIgoA/rjmAwopGaP1VeGtOGtRKdiwmkjomOETkUgsmJuGm1BiYLFY88NEeNLV1uPX1V209jv/uOQ2FXIZ/zh6NfhGBbn19IhIHExwicimZTIaX7hiBhPAAnDpzFg9/XgizxeqW1950pBbPf1cMAPjz9CEYPyDSLa9LROJjgkNELqf1V+Gfs0fDTynHTyU1ePDjPTCaXbvr+NHaFiz6eA+sAnDXmHjuFE7kY5jgEJFbDO2jxRudSc66omos/KAA7R2uSXIKKxpx15s70NxuRlq/MDw98xp2KybyMUxwiMhtpg6Jwep7r4W/SoFNR2ox9918p2/nsK5Ij1lv7UBdiwmpsSFYeTcnFRP5IiY4RORWEwZG4oP5YxGkVmLnsQbcsyoPjW0mpzz36q3Hcd+HBWjvsGLK4Ch8fl8GooLVTnluIvIuLktwnnvuOYwbNw4BAQEIDQ3t0WMEQcCyZcsQGxsLf39/ZGZmorS0tMsxDQ0NmD17NkJCQhAaGor58+ejpaXFBe+AiFzl2sRwfPS7dGj9Vdhb3ojMVzbjPwWnYLVeWTPAVqMZf/m6CE+vPQRBAH6TnoB35oxBkFrp5MiJyFu4LMExmUy44447cP/99/f4MS+++CJeffVVrFy5Enl5eQgMDERWVhba29sdx8yePRtFRUVYv3491q5di82bN2PhwoWueAtE5EIj4kPx2f9ch6TIQNS1GPHIF/twx5s7UFTZ1OPnaDOZ8eamo5j44ga8t/0EAOCJm1Pw3MyhUCo4QE3ky2SCi/unv/fee1i8eDEaGxsveZwgCIiLi8MjjzyC//3f/wUANDU1ISYmBu+99x5mzZqF4uJipKamYteuXRgzZgwAICcnB9OmTcOpU6cQFxfXo5gMBgO0Wi2ampoQEhJyVe+PiK6OyWzFqq3H8dpPpWgzWSCXAbeP7ospg6MxJjEMMSGaLscLgoCaZiO+2VeJlZuOoq7FVt7qFxGAP00bgpuu0YnxNojIDXrz/e0x47fHjx+HXq9HZmam4z6tVov09HTs2LEDs2bNwo4dOxAaGupIbgAgMzMTcrkceXl5+OUvf9ntcxuNRhiNRse/DQbP2d2YyNf5KeW4f0oyZo6Kw3PfFmPt/ip8UXAKXxScAgD0CfXHqIRQGM1WlNe34WRDK9o7zvXRiQ/3xx9uGIhfjurDURsicvCYBEev1wMAYmJiutwfExPj+Jler0d0dHSXnyuVSoSHhzuO6c7y5cvx17/+1ckRE5EzxWr98fpvRuOe6+rx7YEq7D5xBiV6A043nsXpxrNdjpXLgOSoIPxuYn/cNrovVExsiOhnepXgPPHEE3jhhRcueUxxcTFSUlKuKihnW7p0KZYsWeL4t8FgQHx8vIgREdHFpCdFID0pAgDQ3N6BwopG7D/VhGCNEgnhAUiMCESfMH8mNUR0Sb1KcB555BHMnTv3ksckJSVdUSA6na1uXl1djdjYWMf91dXVGDlypOOYmpqaLo8zm81oaGhwPL47arUaajWXihJ5m2CNChMHRmHiwCixQyEiL9OrBCcqKgpRUa450fTv3x86nQ65ubmOhMZgMCAvL8+xEisjIwONjY0oKChAWloaAOCnn36C1WpFenq6S+IiIiIi7+OyMd7y8nIUFhaivLwcFosFhYWFKCws7NKzJiUlBWvWrAFg25Bv8eLFePbZZ/H111/jwIEDmDNnDuLi4jBz5kwAwJAhQ5CdnY0FCxYgPz8f27Ztw6JFizBr1qwer6AiIiIi6XPZJONly5bh/fffd/x71KhRAIANGzZgypQpAIDDhw+jqelcz4vHHnsMra2tWLhwIRobGzFhwgTk5ORAozm3TPSjjz7CokWLMHXqVMjlctx+++149dVXXfU2iIiIyAu5vA+OJ2IfHCIiIu/Tm+9vLkMgIiIiyWGCQ0RERJLDBIeIiIgkhwkOERERSQ4THCIiIpIcJjhEREQkOUxwiIiISHKY4BAREZHkMMEhIiIiyXHZVg2ezN682WAwiBwJERER9ZT9e7snmzD4ZILT3NwMAIiPjxc5EiIiIuqt5uZmaLXaSx7jk3tRWa1WVFZWIjg4GDKZzKnPbTAYEB8fj4qKCu5z5WL8rN2Hn7X78LN2H37W7uOsz1oQBDQ3NyMuLg5y+aVn2fjkCI5cLkffvn1d+hohISH8g3ETftbuw8/affhZuw8/a/dxxmd9uZEbO04yJiIiIslhgkNERESSwwTHydRqNZ566imo1WqxQ5E8ftbuw8/affhZuw8/a/cR47P2yUnGREREJG0cwSEiIiLJYYJDREREksMEh4iIiCSHCQ4RERFJDhMcJ1qxYgUSExOh0WiQnp6O/Px8sUOSnOXLl+Paa69FcHAwoqOjMXPmTBw+fFjssHzC3/72N8hkMixevFjsUCTp9OnTuPvuuxEREQF/f38MGzYMu3fvFjssSbJYLHjyySfRv39/+Pv7Izk5Gc8880yP9jeiS9u8eTNuueUWxMXFQSaT4csvv+zyc0EQsGzZMsTGxsLf3x+ZmZkoLS11SSxMcJzks88+w5IlS/DUU09hz549GDFiBLKyslBTUyN2aJKyadMmPPjgg9i5cyfWr1+Pjo4O3HTTTWhtbRU7NEnbtWsX3nzzTQwfPlzsUCTpzJkzGD9+PFQqFb7//nscOnQIf//73xEWFiZ2aJL0wgsv4I033sDrr7+O4uJivPDCC3jxxRfx2muviR2a12ttbcWIESOwYsWKbn/+4osv4tVXX8XKlSuRl5eHwMBAZGVlob293fnBCOQUY8eOFR588EHHvy0WixAXFycsX75cxKikr6amRgAgbNq0SexQJKu5uVkYOHCgsH79emHy5MnCQw89JHZIkvP4448LEyZMEDsMnzF9+nTht7/9bZf7brvtNmH27NkiRSRNAIQ1a9Y4/m21WgWdTie89NJLjvsaGxsFtVotfPLJJ05/fY7gOIHJZEJBQQEyMzMd98nlcmRmZmLHjh0iRiZ9TU1NAIDw8HCRI5GuBx98ENOnT+/y+03O9fXXX2PMmDG44447EB0djVGjRuHtt98WOyzJGjduHHJzc3HkyBEAwL59+7B161bcfPPNIkcmbcePH4der+9yLtFqtUhPT3fJd6VPbrbpbHV1dbBYLIiJielyf0xMDEpKSkSKSvqsVisWL16M8ePHY+jQoWKHI0mffvop9uzZg127dokdiqQdO3YMb7zxBpYsWYI//vGP2LVrF/7whz/Az88P9957r9jhSc4TTzwBg8GAlJQUKBQKWCwWPPfcc5g9e7bYoUmaXq8HgG6/K+0/cyYmOOS1HnzwQRw8eBBbt24VOxRJqqiowEMPPYT169dDo9GIHY6kWa1WjBkzBs8//zwAYNSoUTh48CBWrlzJBMcFPv/8c3z00Uf4+OOPcc0116CwsBCLFy9GXFwcP28JYYnKCSIjI6FQKFBdXd3l/urqauh0OpGikrZFixZh7dq12LBhA/r27St2OJJUUFCAmpoajB49GkqlEkqlEps2bcKrr74KpVIJi8UidoiSERsbi9TU1C73DRkyBOXl5SJFJG2PPvoonnjiCcyaNQvDhg3DPffcg4cffhjLly8XOzRJs38fuuu7kgmOE/j5+SEtLQ25ubmO+6xWK3Jzc5GRkSFiZNIjCAIWLVqENWvW4KeffkL//v3FDkmypk6digMHDqCwsNBxGzNmDGbPno3CwkIoFAqxQ5SM8ePHX9Du4MiRI+jXr59IEUlbW1sb5PKuX38KhQJWq1WkiHxD//79odPpunxXGgwG5OXlueS7kiUqJ1myZAnuvfdejBkzBmPHjsU//vEPtLa2Yt68eWKHJikPPvggPv74Y3z11VcIDg521G21Wi38/f1Fjk5agoODL5jbFBgYiIiICM55crKHH34Y48aNw/PPP48777wT+fn5eOutt/DWW2+JHZok3XLLLXjuueeQkJCAa665Bnv37sUrr7yC3/72t2KH5vVaWlpQVlbm+Pfx48dRWFiI8PBwJCQkYPHixXj22WcxcOBA9O/fH08++STi4uIwc+ZM5wfj9HVZPuy1114TEhISBD8/P2Hs2LHCzp07xQ5JcgB0e3v33XfFDs0ncJm463zzzTfC0KFDBbVaLaSkpAhvvfWW2CFJlsFgEB566CEhISFB0Gg0QlJSkvCnP/1JMBqNYofm9TZs2NDtOfree+8VBMG2VPzJJ58UYmJiBLVaLUydOlU4fPiwS2KRCQJbNxIREZG0cA4OERERSQ4THCIiIpIcJjhEREQkOUxwiIiISHKY4BAREZHkMMEhIiIiyWGCQ0RERJLDBIeIiIgkhwkOERERSQ4THCIiIpIcJjhEREQkOUxwiIiISHL+P9EkQPOj1DixAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@igogo.job(warn_rewrite=False)\n", + "def run():\n", + " for i in range(1, 100):\n", + " x = np.linspace(0, i / 10, 100)\n", + " plt.plot(\n", + " x,\n", + " f(x)\n", + " )\n", + " igogo.sleep(0.05)\n", + " return \"success\"\n", + " \n", + "\n", + "result = run()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dd964f3e-f77d-467a-95f9-245336d118da", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 1)\n", + "plt.plot(\n", + " x,\n", + " np.cos(x)\n", + ");" + ] + } + ], + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/display_custom.ipynb b/examples/display_custom.ipynb new file mode 100644 index 0000000..92a74db --- /dev/null +++ b/examples/display_custom.ipynb @@ -0,0 +1,134 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6904abef-fe38-4e77-b433-0b5569d6c825", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "%load_ext igogo\n", + "import igogo" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "da3dc035-52cf-42f8-a5de-52b5fb8e5fc3", + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return np.sin(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b365f3db-acd6-43b4-a2d4-8be53f4276b8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@igogo.job(warn_rewrite=False, displays=2)\n", + "def run():\n", + " for i in range(1, 100):\n", + " x = np.linspace(0, i / 10, 100)\n", + " fig = plt.figure()\n", + " plt.plot(\n", + " x,\n", + " f(x)\n", + " )\n", + " igogo.display(fig)\n", + " \n", + " fig = plt.figure()\n", + " plt.scatter(\n", + " x,\n", + " f(x)\n", + " )\n", + " igogo.display(fig)\n", + " igogo.sleep(0.02)\n", + " return \"success\"\n", + " \n", + "\n", + "result = run()" + ] + } + ], + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/hello_world.ipynb b/examples/hello_world.ipynb new file mode 100644 index 0000000..fdaf4df --- /dev/null +++ b/examples/hello_world.ipynb @@ -0,0 +1,120 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "0c6f9554-c2c8-4c31-952a-4599234331c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import igogo\n", + "\n", + "@igogo.job\n", + "def hello_world(name):\n", + " for i in range(3):\n", + " print(\"Hello, world from\", name)\n", + " \n", + " # allows other jobs to run while asleep\n", + " # also can be `igogo.yielder()`\n", + " igogo.sleep(1) \n", + " return name" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e448de2f-d7e5-4bea-9f8e-6be34ebfc7cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Hello, world from igogo\n", + "Hello, world from igogo\n", + "Hello, world from igogo\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Hello, world from other igogo\n", + "Hello, world from other igogo\n", + "Hello, world from other igogo\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hello_world('igogo'), hello_world('other igogo');" + ] + } + ], + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/monitor.ipynb b/examples/monitor.ipynb new file mode 100644 index 0000000..a4331d1 --- /dev/null +++ b/examples/monitor.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "id": "2dd6ab80-bf7c-46e5-be94-472a0ee599a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The igogo extension is already loaded. To reload it, use:\n", + " %reload_ext igogo\n" + ] + } + ], + "source": [ + "import igogo\n", + "import numpy as np\n", + "from tqdm.auto import tqdm\n", + "%load_ext igogo\n", + "\n", + "raw_data = np.random.randn(100000, 100)\n", + "result = []" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0e155562-baad-48e6-994d-16bbdb62131d", + "metadata": {}, + "outputs": [], + "source": [ + "def row_processor(row):\n", + " return np.mean(row)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cab57e5d-9942-48d7-a704-588104c8d65b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bdcc347008df44f2b2f43fe9c9c4d421", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hello_world_matplotlib(\"cos\", np.cos)\n", + "hello_world_matplotlib(\"sin\", np.sin)\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "aa9acfa7-347c-4266-bb28-b7cdc8df2431", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "experiment(\"atan\", np.arctan, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45263716-264f-4e89-9009-26bd1b1e005e", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/igogo/context.py b/igogo/context.py index b0a7249..d012288 100644 --- a/igogo/context.py +++ b/igogo/context.py @@ -3,7 +3,7 @@ import asyncio import contextvars -from typing import Optional +from typing import Optional, List from .output import OutputStreamsSetter, OutputObject, AdditionalOutputs from .exceptions import IgogoInvalidContext @@ -17,11 +17,19 @@ class IgogoContext(object): task: asyncio.Task additional_outputs: AdditionalOutputs - def __init__(self, task: asyncio.Task, out_stream: OutputStreamsSetter, additional_outputs: AdditionalOutputs): + def __init__( + self, + task: asyncio.Task, + out_stream: OutputStreamsSetter, + additional_outputs: AdditionalOutputs + ): self.out_stream = out_stream self.task = task self.additional_outputs = additional_outputs + out_stream.register_activate_callback(additional_outputs.after_context_enter) + out_stream.register_deactivate_callback(additional_outputs.before_context_exit) + _context: contextvars.ContextVar[Optional[IgogoContext]] = contextvars.ContextVar("igogo_context", default=None) diff --git a/igogo/core.py b/igogo/core.py index 3d2b1f3..5f3e225 100644 --- a/igogo/core.py +++ b/igogo/core.py @@ -5,10 +5,11 @@ import functools import inspect import sys -from typing import Dict, List +from typing import Dict, List, Any import traceback import IPython +import matplotlib.pyplot as plt from IPython import display as ipydisplay import greenback import ipywidgets @@ -105,13 +106,16 @@ def sleep(delay, result=None): value.out_stream.activate() -def display(object): +def display(object: Any, close_if_figure: bool = True): """ Display an object in the output widget of the current cell. Fallback to regular display if there's no igogo job + This will close pyplot figure by default so that it is not displayed twice + Args: - object (object): The object to display. + object (Any): The object to display. + close_if_figure (bool): Close object if it is pyplot figure Raises: IgogoAdditionalOutputsExhausted: If there are no additional output widgets available. @@ -125,6 +129,8 @@ def display(object): raise IgogoAdditionalOutputsExhausted() out = value.additional_outputs.get_next() out.add_object(object) + if isinstance(object, plt.Figure) and close_if_figure: + plt.close(object) def clear_output(including_text=True): @@ -259,7 +265,8 @@ def on_button_clicked(b): _cell_widgets_display_ids[cell_id].update(result_widget) -def job(original_function=None, kind='stdout', displays=10, name='', warn_rewrite=True, verbose=False): +def job(original_function=None, kind='stdout', displays=1, name='', warn_rewrite=True, verbose=False, + auto_display_figures=True): """ This function decorates a given function with functionality to run it as igogo job. Call to decorated function returns dictionary where 'task' represents a spawned job. @@ -268,6 +275,8 @@ def job(original_function=None, kind='stdout', displays=10, name='', warn_rewrit :param displays: number of spawned spare displays :param name: human-readable igogo job name :param warn_rewrite: warn if older displays are rewritten + :param verbose: print debug igogo information + :param auto_display_figures: display figures created inside igogo automatically """ global _igogo_count @@ -285,15 +294,22 @@ def wrapped_function(*args, **kwargs): _cell_widgets_display_ids.setdefault(ex_count, widget_handle) output_stream = OutputStreamsSetter(stdout=OutputText(kind=kind), stderr=OutputText(kind='stderr')) - additional_outputs = AdditionalOutputs(count=displays, no_warn=not warn_rewrite) + additional_outputs = AdditionalOutputs( + count=displays, + no_warn=not warn_rewrite, + auto_display_figures=auto_display_figures + ) async def func_context_setter(): if verbose: _log_warning('Ensuring has portal') await greenback.ensure_portal() - set_context( - IgogoContext(task, output_stream, additional_outputs) + context = IgogoContext( + task, + output_stream, + additional_outputs ) + set_context(context) if verbose: _log_warning('About to set outputs') output_stream.activate() diff --git a/igogo/output.py b/igogo/output.py index 574b0b2..22a23f0 100644 --- a/igogo/output.py +++ b/igogo/output.py @@ -7,6 +7,7 @@ import sys from typing import List +import matplotlib.pyplot as plt from IPython import display from IPython.core.interactiveshell import InteractiveShell @@ -119,10 +120,13 @@ def flush(self): ... class OutputStreamsSetter: + def __init__(self, stdout: OutputText, stderr: OutputText): self.stdout = stdout self.stderr = stderr self.activated = False + self._deactivate_callbacks = [] + self._activate_callbacks = [] def _exchange(self): self.stdout, sys.stdout = sys.stdout, self.stdout @@ -132,22 +136,41 @@ def activate(self, force=False): if not self.activated or force: self._exchange() self.activated = True + self._run_activate_callbacks() def deactivate(self, force=False): if self.activated or force: + self._run_deactivate_callbacks() self._exchange() self.activated = False + def _run_activate_callbacks(self): + for f in self._activate_callbacks: + f() + + def _run_deactivate_callbacks(self): + for f in self._deactivate_callbacks: + f() + + def register_activate_callback(self, f): + self._activate_callbacks.append(f) + + def register_deactivate_callback(self, f): + self._deactivate_callbacks.append(f) + class AdditionalOutputs: additional_outputs: List[OutputObject] counter: int no_warn: bool + enter_figs_num: List[int] + auto_display_figures: bool - def __init__(self, count=1, no_warn=False): + def __init__(self, count=1, no_warn=False, auto_display_figures=True): self.additional_outputs = [OutputObject() for _ in range(count)] self.counter = 0 self.no_warn = no_warn + self.auto_display_figures = auto_display_figures def get_next(self): if self.counter == len(self.additional_outputs) and not self.no_warn: @@ -162,3 +185,13 @@ def is_empty(self): def clear(self): for disp in self.additional_outputs: disp.clear() + + def after_context_enter(self): + self.enter_figs_num = plt.get_fignums() + + def before_context_exit(self): + if self.auto_display_figures and self.enter_figs_num != plt.get_fignums(): + from .core import display as igogo_display + fig = plt.gcf() + igogo_display(fig) + plt.close(fig) diff --git a/igogo/yielder.py b/igogo/yielder.py index a4600d1..aef0ce5 100644 --- a/igogo/yielder.py +++ b/igogo/yielder.py @@ -35,9 +35,11 @@ def igogo_await(cls): if len(get_running_igogo_cells()) == 0: return value = get_context_or_fail() + value.out_stream.deactivate() greenback.await_(cls()) value.out_stream.activate() + value.additional_outputs.after_context_enter() def __await__(self): """ diff --git a/pyproject.toml b/pyproject.toml index 81b20d6..13206a9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,13 +4,13 @@ build-backend = "hatchling.build" [project] name = "igogo" -version = "1.0.3" +version = "1.1.0" authors = [ { name = "Alex Dremov", email = "igogo@alexdremov.me" }, ] description = "Execute several jupyter cells simultaneously" readme = "README.md" -requires-python = ">=3.7" +requires-python = ">=3.8" license = "MIT" classifiers = [ "Programming Language :: Python :: 3", @@ -20,11 +20,12 @@ classifiers = [ keywords = ["jupyterlab", "ipython", "jupyter", "execute", "python"] dependencies = [ 'IPython >= 8.0.0', - 'greenback >= 1.1.1' + 'greenback >= 1.1.1', + 'matplotlib >= 3.5.0' ] packages = [ { include = "igogo" } ] [project.urls] -"Homepage" = "https://github.com/AlexRoar/igogo" +"Homepage" = "https://github.com/alexdremov/igogo"