From 31223adbaf3f9600db47458085c7b7ba211d8708 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Mon, 14 Jun 2021 09:49:40 -0500 Subject: [PATCH 01/52] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 6aa6744..a01f673 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +[![Build Status](https://travis-ci.org/hapi-server/plot-python.svg?branch=main)](https://travis-ci.org/hapi-server/plot-python) + **HAPI plotting client for Python 3.6+** # Installation From ab973fa1d908148225fb93dc78aefcc025176b85 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 12:42:38 -0400 Subject: [PATCH 02/52] autoplot fix --- MANIFEST.in | 1 + hapiplot/__init__.py | 3 +++ hapiplot/autoplot/autoplot_test.py | 3 ++- setup.py | 3 ++- 4 files changed, 8 insertions(+), 2 deletions(-) create mode 100644 MANIFEST.in diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..0f866c4 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1 @@ +include hapiplot/autoplot/server.jy \ No newline at end of file diff --git a/hapiplot/__init__.py b/hapiplot/__init__.py index fa04cd2..043aa28 100644 --- a/hapiplot/__init__.py +++ b/hapiplot/__init__.py @@ -1,6 +1,9 @@ # Allow "from hapiplot import hapiplot" from hapiplot.hapiplot import hapiplot +# Allow "from hapiplot import autoplot" +from hapiplot.autoplot import autoplot + # This is needed because setopts reads all rcParams and adds passed rcParams. # The default rcParams include those that are depricated and so a warning is # generated when these rcParams are used with a context manager. diff --git a/hapiplot/autoplot/autoplot_test.py b/hapiplot/autoplot/autoplot_test.py index 5260376..9610ebf 100644 --- a/hapiplot/autoplot/autoplot_test.py +++ b/hapiplot/autoplot/autoplot_test.py @@ -1,4 +1,4 @@ -from hapiclient import autoplot +from hapiplot.autoplot.autoplot import autoplot server = 'http://hapi-server.org/servers/TestData2.0/hapi' dataset = 'dataset1' @@ -6,4 +6,5 @@ stop = '1970-01-01T00:00:11Z' parameters = 'scalar,vector' opts = {'logging': True, 'usecache': False, 'version': 'nightly'} + autoplot(server, dataset, parameters, start, stop, **opts) diff --git a/setup.py b/setup.py index 1ec5058..7dd41cc 100644 --- a/setup.py +++ b/setup.py @@ -4,7 +4,7 @@ #install_requires = ["matplotlib", "hapiclient @ git+https://github.com/hapi-server/client-python#egg=hapiclient"] install_requires = ["matplotlib", "hapiclient>0.1.7"] -if sys.argv[1] == 'develop': +if len(sys.argv) > 1 and sys.argv[1] == 'develop': install_requires.append("deepdiff<3.3.0") if sys.version_info < (3, 6): install_requires.append("pytest<5.0.0") @@ -25,5 +25,6 @@ license='LICENSE.txt', description='Plot data from HAPI server', long_description=open('README.md').read(), + include_package_data=True, install_requires=install_requires ) \ No newline at end of file From 7b31ad17bf69a512488096981ca175b758b5c093 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 12:43:29 -0400 Subject: [PATCH 03/52] Last 0.0.1b4 commit --- CHANGES.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGES.txt b/CHANGES.txt index 9bd3639..b55ddc1 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -6,4 +6,5 @@ v0.0.1b3: 2021-05-26 33ed6b6 Update README.md 2021-05-26 411f7a3 Fix README file extension 2021-05-26 c8ec6ad Add actual package files -v0.0.1b4: \ No newline at end of file +v0.0.1b4: + 2021-06-14 ab973fa Autoplot fix \ No newline at end of file From a553e2eda7ac0f305a59b8b6f877f8c30de781d9 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 12:44:32 -0400 Subject: [PATCH 04/52] Last 0.0.1b4 commit --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 86e826b..3d6dc84 100644 --- a/Makefile +++ b/Makefile @@ -203,8 +203,8 @@ version-update: python misc/version.py version-tag: - git commit -a -m "Last $(VERSION) commit" - git push + - git commit -a -m "Last $(VERSION) commit" + - git push git tag -a v$(VERSION) -m "Version "$(VERSION) git push --tags ################################################################################ From 22dc18bbe7aa4b6b0734cb4a72db5409486f307f Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 16:26:52 -0400 Subject: [PATCH 05/52] Autoplot import syntax --- CHANGES.txt | 3 ++- hapiplot/__init__.py | 2 +- hapiplot/autoplot/autoplot_test.py | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index b55ddc1..f09837f 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -7,4 +7,5 @@ v0.0.1b3: 2021-05-26 411f7a3 Fix README file extension 2021-05-26 c8ec6ad Add actual package files v0.0.1b4: - 2021-06-14 ab973fa Autoplot fix \ No newline at end of file + 2021-06-14 ab973fa Autoplot fix + 2021-06-14 Autoplot fix \ No newline at end of file diff --git a/hapiplot/__init__.py b/hapiplot/__init__.py index 043aa28..8198295 100644 --- a/hapiplot/__init__.py +++ b/hapiplot/__init__.py @@ -2,7 +2,7 @@ from hapiplot.hapiplot import hapiplot # Allow "from hapiplot import autoplot" -from hapiplot.autoplot import autoplot +from hapiplot.autoplot.autoplot import autoplot # This is needed because setopts reads all rcParams and adds passed rcParams. # The default rcParams include those that are depricated and so a warning is diff --git a/hapiplot/autoplot/autoplot_test.py b/hapiplot/autoplot/autoplot_test.py index 9610ebf..31dd9ff 100644 --- a/hapiplot/autoplot/autoplot_test.py +++ b/hapiplot/autoplot/autoplot_test.py @@ -1,4 +1,4 @@ -from hapiplot.autoplot.autoplot import autoplot +from hapiplot import autoplot server = 'http://hapi-server.org/servers/TestData2.0/hapi' dataset = 'dataset1' From 81555c10c9fdc6f79408ecdb1ff23da0f02e44e2 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 18:34:02 -0400 Subject: [PATCH 06/52] Last 0.0.1b5 commit --- CHANGES.txt | 3 ++- Makefile | 2 +- hapiplot/__init__.py | 2 +- hapiplot/hapiplot.py | 2 +- setup.py | 2 +- 5 files changed, 6 insertions(+), 5 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index f09837f..fee1925 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -8,4 +8,5 @@ v0.0.1b3: 2021-05-26 c8ec6ad Add actual package files v0.0.1b4: 2021-06-14 ab973fa Autoplot fix - 2021-06-14 Autoplot fix \ No newline at end of file + 2021-06-14 22dc18b Autoplot import syntax +v0.0.1b5: diff --git a/Makefile b/Makefile index 3d6dc84..976e5d3 100644 --- a/Makefile +++ b/Makefile @@ -8,7 +8,7 @@ PYTHONVERS=python3.8 python3.7 python3.6 # VERSION is updated in "make version-update" step and derived # from CHANGES.txt. Do not edit. -VERSION=0.0.1b4 +VERSION=0.0.1b5 SHELL:= /bin/bash LONG_TESTS=false diff --git a/hapiplot/__init__.py b/hapiplot/__init__.py index 8198295..e2f8c3f 100644 --- a/hapiplot/__init__.py +++ b/hapiplot/__init__.py @@ -13,4 +13,4 @@ #ignores = ['datapath','savefig.frameon', 'text.latex.unicode', 'verbose.fileo', 'verbose.level', 'datapath'] warnings.filterwarnings(action='ignore', category=UserWarning) -__version__ = '0.0.1b4' \ No newline at end of file +__version__ = '0.0.1b5' \ No newline at end of file diff --git a/hapiplot/hapiplot.py b/hapiplot/hapiplot.py index 189c662..ac6b3d4 100644 --- a/hapiplot/hapiplot.py +++ b/hapiplot/hapiplot.py @@ -17,7 +17,7 @@ def hapiplot(*args, **kwargs): """Plot response from HAPI server. - Version: 0.0.1b4 + Version: 0.0.1b5 Demos ----- diff --git a/setup.py b/setup.py index 7dd41cc..c044f3c 100644 --- a/setup.py +++ b/setup.py @@ -17,7 +17,7 @@ # version is modified by misc/version.py (executed from Makefile). Do not edit. setup( name='hapiplot', - version='0.0.1b4', + version='0.0.1b5', author='Bob Weigel', author_email='rweigel@gmu.edu', packages=find_packages(), From ab3eeaf990a1912d298d4fb769a0799ec3cc703d Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 18:36:00 -0400 Subject: [PATCH 07/52] Last 0.0.1b5 commit --- hapiplot/__init__.py | 3 +++ hapiplot/gallery/gallery_test.py | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/hapiplot/__init__.py b/hapiplot/__init__.py index e2f8c3f..63c7b28 100644 --- a/hapiplot/__init__.py +++ b/hapiplot/__init__.py @@ -4,6 +4,9 @@ # Allow "from hapiplot import autoplot" from hapiplot.autoplot.autoplot import autoplot +# Allow "from hapiplot import gallery" +from hapiplot.gallery.gallery import gallery + # This is needed because setopts reads all rcParams and adds passed rcParams. # The default rcParams include those that are depricated and so a warning is # generated when these rcParams are used with a context manager. diff --git a/hapiplot/gallery/gallery_test.py b/hapiplot/gallery/gallery_test.py index 1565aae..dcda34d 100644 --- a/hapiplot/gallery/gallery_test.py +++ b/hapiplot/gallery/gallery_test.py @@ -1,7 +1,7 @@ if True: - from hapiclient import gallery + from hapiplot import gallery gallery('http://hapi-server.org/servers/TestData2.0/hapi', 'dataset1', loglevel='debug') if False: - from hapiclient import gallery + from hapiplot import gallery gallery('http://hapi-server.org/servers/TestData2.0/hapi','dataset1', 'vector') From 8c966c3280fc2bf615cdd5e1095e4d2d4d5e2a78 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 18:59:03 -0400 Subject: [PATCH 08/52] gallery fixes --- CHANGES.txt | 2 ++ hapiplot/gallery/gallery.py | 25 +++++++++++++++++++++++-- 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index fee1925..b3d3fed 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -10,3 +10,5 @@ v0.0.1b4: 2021-06-14 ab973fa Autoplot fix 2021-06-14 22dc18b Autoplot import syntax v0.0.1b5: +v0.0.1b6: + 2021-06-14 22dc18b Autoplot import syntax diff --git a/hapiplot/gallery/gallery.py b/hapiplot/gallery/gallery.py index f5058b8..3d3a137 100644 --- a/hapiplot/gallery/gallery.py +++ b/hapiplot/gallery/gallery.py @@ -1,3 +1,20 @@ +def prompt(msg): + '''Python 2/3 imput compatability function. Pauses for user input. + + If Python 3, calls + + `input(msg)` + + If Python 2, calls + + `raw_input(msg)` + ''' + import sys + if sys.version_info[0] > 2: + input(msg) + else: + raw_input(msg) + def gallery(*args, **kwargs): """Create a web-browsable gallery of plots (aka "PNG Walk"). @@ -44,7 +61,7 @@ def gallery(*args, **kwargs): from multiprocessing import Process from hapiclient.hapi import cachedir - from hapiclient.util import error, warning, setopts, prompt + from hapiclient.util import error, warning, setopts from hapiplotserver import hapiplotserver if len(args) != 2 and len(args) !=3: @@ -92,8 +109,12 @@ def gallery(*args, **kwargs): url = url + '&format=gallery' try: - process = Process(target=hapiplotserver, kwargs=opts) + #kwargs = {'port': opts['port'], 'workers': 2, 'loglevel': loglevel} + import multiprocessing as mp + process = mp.Process(target=hapiplotserver, kwargs=opts) process.start() + print("gallery.py: Sleeping for 3 seconds while server starts.") + time.sleep(3) except Exception as e: print(e) print("Terminating server.") From 273d737211c334445182ff387a558c2745e5b89b Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Tue, 15 Jun 2021 18:59:37 -0400 Subject: [PATCH 09/52] Last 0.0.1b6 commit --- CHANGES.txt | 2 +- Makefile | 2 +- hapiplot/__init__.py | 2 +- hapiplot/hapiplot.py | 2 +- setup.py | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index b3d3fed..a66785a 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -11,4 +11,4 @@ v0.0.1b4: 2021-06-14 22dc18b Autoplot import syntax v0.0.1b5: v0.0.1b6: - 2021-06-14 22dc18b Autoplot import syntax + 2021-06-14 8c966c3 gallery fixes diff --git a/Makefile b/Makefile index 976e5d3..89109f4 100644 --- a/Makefile +++ b/Makefile @@ -8,7 +8,7 @@ PYTHONVERS=python3.8 python3.7 python3.6 # VERSION is updated in "make version-update" step and derived # from CHANGES.txt. Do not edit. -VERSION=0.0.1b5 +VERSION=0.0.1b6 SHELL:= /bin/bash LONG_TESTS=false diff --git a/hapiplot/__init__.py b/hapiplot/__init__.py index 63c7b28..ab2d0cf 100644 --- a/hapiplot/__init__.py +++ b/hapiplot/__init__.py @@ -16,4 +16,4 @@ #ignores = ['datapath','savefig.frameon', 'text.latex.unicode', 'verbose.fileo', 'verbose.level', 'datapath'] warnings.filterwarnings(action='ignore', category=UserWarning) -__version__ = '0.0.1b5' \ No newline at end of file +__version__ = '0.0.1b6' \ No newline at end of file diff --git a/hapiplot/hapiplot.py b/hapiplot/hapiplot.py index ac6b3d4..a3d6a97 100644 --- a/hapiplot/hapiplot.py +++ b/hapiplot/hapiplot.py @@ -17,7 +17,7 @@ def hapiplot(*args, **kwargs): """Plot response from HAPI server. - Version: 0.0.1b5 + Version: 0.0.1b6 Demos ----- diff --git a/setup.py b/setup.py index c044f3c..ef387f7 100644 --- a/setup.py +++ b/setup.py @@ -17,7 +17,7 @@ # version is modified by misc/version.py (executed from Makefile). Do not edit. setup( name='hapiplot', - version='0.0.1b5', + version='0.0.1b6', author='Bob Weigel', author_email='rweigel@gmu.edu', packages=find_packages(), From 52cccf4f952b5a784dd780c980fbe9b4117bbd82 Mon Sep 17 00:00:00 2001 From: Bob Weigel Date: Wed, 16 Jun 2021 09:51:07 -0400 Subject: [PATCH 10/52] Created using Colaboratory --- hapi_demo.ipynb | 3847 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3847 insertions(+) create mode 100644 hapi_demo.ipynb diff --git a/hapi_demo.ipynb b/hapi_demo.ipynb new file mode 100644 index 0000000..c199209 --- /dev/null +++ b/hapi_demo.ipynb @@ -0,0 +1,3847 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "git": { + "suppress_output": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + }, + "colab": { + "name": "hapi_demo.ipynb", + "provenance": [], + "toc_visible": true + } + }, + "cells": [ + { + "cell_type": "code", + "metadata": { + "id": "Q5L4NSn4W6Dg", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "cc36fac5-5422-436b-b34e-23253ae1b192" + }, + "source": [ + "!pip uninstall -y hapiclient hapiplot; pip install --pre hapiclient hapiplot\n", + "# Show plots in page instead of opening a window\n", + "%matplotlib inline" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: Skipping hapiclient as it is not installed.\u001b[0m\n", + "\u001b[33mWARNING: Skipping hapiplot as it is not installed.\u001b[0m\n", + "Collecting hapiclient\n", + " Downloading https://files.pythonhosted.org/packages/49/af/fb973c53d83d7c554e108ca65eb82ceca7a01234389dc02973463165b051/hapiclient-0.1.9b3.tar.gz\n", + "Collecting hapiplot\n", + " Downloading https://files.pythonhosted.org/packages/11/cf/7f24a1d8e0432389414cc5865e52ce46f14831ba245802bf01e3760415db/hapiplot-0.0.1b6.tar.gz\n", + "Collecting isodate>=0.6.0\n", + "\u001b[?25l Downloading https://files.pythonhosted.org/packages/9b/9f/b36f7774ff5ea8e428fdcfc4bb332c39ee5b9362ddd3d40d9516a55221b2/isodate-0.6.0-py2.py3-none-any.whl (45kB)\n", + "\u001b[K |████████████████████████████████| 51kB 4.2MB/s \n", + "\u001b[?25hRequirement already satisfied: urllib3 in /usr/local/lib/python3.7/dist-packages (from hapiclient) (1.24.3)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from hapiclient) (1.0.1)\n", + "Requirement already satisfied: pandas>=0.23 in /usr/local/lib/python3.7/dist-packages (from hapiclient) (1.1.5)\n", + "Requirement already satisfied: numpy>=1.14.3 in /usr/local/lib/python3.7/dist-packages (from hapiclient) (1.19.5)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from hapiplot) (3.2.2)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from isodate>=0.6.0->hapiclient) (1.15.0)\n", + "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.23->hapiclient) (2018.9)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.23->hapiclient) (2.8.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->hapiplot) (0.10.0)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->hapiplot) (2.4.7)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->hapiplot) (1.3.1)\n", + "Building wheels for collected packages: hapiclient, hapiplot\n", + " Building wheel for hapiclient (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for hapiclient: filename=hapiclient-0.1.9b3-cp37-none-any.whl size=28795 sha256=0ddc05345eb3096eff12ebd925772394a81c3c2d1bbfd5d671b2072da0238437\n", + " Stored in directory: /root/.cache/pip/wheels/57/03/e4/cd187f72557fa766ad674b6d3b4676c9e3850f17f75992a913\n", + " Building wheel for hapiplot (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for hapiplot: filename=hapiplot-0.0.1b6-cp37-none-any.whl size=36739 sha256=ca320b6a24f4813808eec3b94be2dace474f7dae02de77ef2a34cf21e6f5594a\n", + " Stored in directory: /root/.cache/pip/wheels/b6/ce/9b/41f96067859e27f3ff9561bd18c55530d6127b3931965e4d5b\n", + "Successfully built hapiclient hapiplot\n", + "Installing collected packages: isodate, hapiclient, hapiplot\n", + "Successfully installed hapiclient-0.1.9b3 hapiplot-0.0.1b6 isodate-0.6.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nPrfD4g5W6Dh" + }, + "source": [ + "The [Heliophysics Application Programmer’s Interface (HAPI)](http://hapi-server.org/) data access specification is a RESTful API and streaming format specification for delivering digital time series data.\n", + "\n", + "This notebook demonstrates the features of a Python client that accesses data from HAPI-compliant data servers.\n", + "\n", + "To use this notebook locally\n", + "\n", + "1. [Install Anaconda](https://www.anaconda.com/download/) for Python 3\n", + "2. On command line enter \n", + "\n", + "```bash\n", + "which pip # Output should contain a directory path with \"anaconda3\"\n", + "pip install hapiclient --upgrade # Install latest hapiclient package\n", + "curl -L -O https://rawgithub.com/hapi-server/client-python-notebooks/master/hapi_demo.ipynb\n", + "jupyter-notebook hapi_demo.ipynb # Launches browser window\n", + "```\n", + "\n", + "To test code in this notebook, click on a code area, edit, and hit `SHIFT-ENTER` to execute.\n", + "\n", + "For more information on HAPI-related software, see http://hapi-server.org/." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ALQ979SQW6Dh" + }, + "source": [ + "# Display documentation" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GqBguSXIW6Dh", + "outputId": "d3cd1645-23dd-4f9d-d401-dc6683abdc9f" + }, + "source": [ + "from hapiclient.hapi import hapi\n", + "help(hapi)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Help on function hapi in module hapiclient.hapi:\n", + "\n", + "hapi(*args, **kwargs)\n", + " Request data from a HAPI server.\n", + " \n", + " Version: 0.1.9b3\n", + " \n", + " \n", + " Examples\n", + " ----------\n", + " `Jupyter Notebook _`\n", + " \n", + " Parameters\n", + " ----------\n", + " server : str\n", + " A string with the URL to a HAPI compliant server. (A HAPI URL\n", + " always ends with \"/hapi\").\n", + " dataset : str\n", + " A string specifying a dataset from a `server`\n", + " parameters: str\n", + " A Comma-separated list of parameters in `dataset`\n", + " start: str\n", + " The start time of the requested data\n", + " stop: str\n", + " The end time of the requested data; end times are exclusive - the\n", + " last data record returned by a HAPI server should have a timestamp\n", + " before `start`.\n", + " options : dict\n", + " \n", + " `logging` (False) - Log to console\n", + " \n", + " `cache` (True) - Save responses and processed responses in cachedir\n", + " \n", + " `cachedir` (./hapi-data)\n", + " \n", + " `usecache` (True) - Use files in `cachedir` if found\n", + " \n", + " `serverlist` (https://github.com/hapi-server/servers/raw/master/all.txt)\n", + " \n", + " `parallel` (False) If true, make up to `n_parallel` requests to\n", + " server in parallel (uses threads)\n", + " \n", + " `n_parallel` (5) Maximum number of parallel requests to server.\n", + " Max allowed is 5.\n", + " \n", + " `n_chunks` (None) Get data by making `n_chunks` requests by splitting\n", + " requested time range. `dt_chunk` is ignored if `n_chunks` is\n", + " not `None`. Allowed values are integers > 1.\n", + " \n", + " `dt_chunk` ('infer') For requests that span a time range larger\n", + " than the default chunk size for a given dataset cadence, the\n", + " client will split request into chunks if `dt_chunk` is not\n", + " `None`.\n", + " \n", + " Allowed values of `dt_chunk` are 'infer', `None`, and an ISO 8601\n", + " duration that is unambiguous (durations that include Y and M are not\n", + " allowed). The default chunk size is determined based on the cadence\n", + " of the dataset requested according to\n", + " \n", + " cadence < PT1S dt_chunk='PT1H'\n", + " PT1S <= cadence <= PT1H dt_chunk='P1D'\n", + " cadence > PT1H dt_chunk='P30D'\n", + " cadence >= P1D dt_chunk='P365D'\n", + " \n", + " If the dataset does not have a cadence listed in its metadata, an\n", + " attempt is made to infer the cadence by requesting a small time range\n", + " of data and doubling the time range until 10 records are in the response.\n", + " The cadence used to determine the chunk size is then the average time\n", + " difference between records.\n", + " \n", + " If requested time range is < 1/2 of chunk size, only one request is\n", + " made. Otherwise, start and/or stop are modified to be at hour, day,\n", + " month or year boundaries and requests are made for a time span of a\n", + " full chunk, and trimming is performed. For example,\n", + " \n", + " Cadence = PT1M and request for\n", + " start/stop=1999-11-12T00:10:00/stop=1999-11-12T12:09:00\n", + " Chunk size is P1D and requested time range < 1/2 of this\n", + " => Default behavior\n", + " Cadence = PT1M and request for\n", + " start/stop=1999-11-12T00:10:00/1999-11-12T12:10:00\n", + " Chunk size is P1D and requested time range >= 1/2 of this\n", + " => One request with start/stop=1999-11-12/1999-11-13\n", + " and trim performed\n", + " Cadence = PT1M and request for\n", + " start/stop=1999-11-12T00:10:00/1999-11-13T12:09:00\n", + " Chunk size is P1D and requested time range > than this\n", + " => Two requests:\n", + " (1) start/stop=1999-11-12/start=1999-11-13\n", + " (2) start/stop=1999-11-13/start=1999-11-14\n", + " and trim performed\n", + " \n", + " \n", + " Returns\n", + " -------\n", + " result : various\n", + " `result` depends on the input parameters.\n", + " \n", + " servers = hapi() returns a list of available HAPI server URLs from\n", + " https://github.com/hapi-server/data-specification/blob/master/all.txt\n", + " \n", + " dataset = hapi(server) returns a dict of datasets available from a\n", + " URL given by the string `server`. The dictionary structure follows the\n", + " HAPI JSON structure.\n", + " \n", + " parameters = hapi(server, dataset) returns a dictionary of parameters\n", + " in the string `dataset`. The dictionary structure follows the HAPI JSON\n", + " structure.\n", + " \n", + " metadata = hapi(server, dataset, parameters) returns metadata\n", + " associated each parameter in the comma-separated string `parameters`. The\n", + " dictionary structure follows the HAPI JSON structure.\n", + " \n", + " data = hapi(server, dataset, parameters, start, stop) returns a\n", + " dictionary with elements corresponding to `parameters`, e.g., if\n", + " `parameters` = 'scalar,vector' and the number of records in the time\n", + " range `start` <= t < `stop` returned is N, then\n", + " \n", + " data['scalar'] is a NumPy array of shape (N)\n", + " data['vector'] is a NumPy array of shape (N,3)\n", + " data['Time'] is a NumPy array of byte literals with shape (N).\n", + " \n", + " Byte literal times can be converted to Python datetimes using\n", + " \n", + " dtarray = hapitime2datetime(data['Time'])\n", + " \n", + " data, meta = hapi(server, dataset, parameters, start, stop) returns\n", + " the metadata for parameters in `meta`.\n", + " \n", + " \n", + " References\n", + " ----------\n", + " * `HAPI Server Definition `_\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HpAQ7hfyW6Di" + }, + "source": [ + "# Examples\n", + "\n", + "## OMNIWeb data" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "tkB38lLbW6Di", + "outputId": "b419e599-c9c7-4c1f-877d-8476131d7c11" + }, + "source": [ + "from hapiclient import hapi\n", + "from hapiplot import hapiplot\n", + "from hapiclient.util import pythonshell\n", + "\n", + "server = 'https://cdaweb.gsfc.nasa.gov/hapi'\n", + "dataset = 'OMNI2_H0_MRG1HR' # See section 5 for information on finding list of datasets\n", + "start = '2003-09-01T00:00:00'\n", + "stop = '2003-12-01T00:00:00'\n", + "parameters = 'DST1800' # See section 5 for information on finding parameters in dataset\n", + "opts = {'logging': True, 'usecache': False}\n", + "\n", + "# Get parameter data. See section 5 for for information on getting available datasets and parameters\n", + "data, meta = hapi(server, dataset, parameters, start, stop, **opts)\n", + "\n", + "# Print meta using display() function if using IPython or Jupyter Notebook\n", + "print(meta) if pythonshell() == 'python' else display(meta)\n", + "\n", + "# Plot all parameters in data. See also section 4 for information\n", + "# on using other plotting functions, e.g., Matplotlib\n", + "hapiplot(data, meta)\n", + "\n", + "# Extract time values as datetime objects. See section 3 for more details.\n", + "from hapiclient import hapitime2datetime\n", + "\n", + "dateTimes = hapitime2datetime(data['Time'])\n", + "print(\"\\ndateTimes = \")\n", + "print(dateTimes) if pythonshell() == 'python' else display(dateTimes)\n", + "\n", + "# Extract one of the parameters as NumPy array\n", + "BGSEc = data['DST1800']\n", + "print(\"\\nDST1800 =\")\n", + "print(dateTimes) if pythonshell() == 'python' else display(dateTimes)\n" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "hapi(): Running hapi.py version 0.1.9b3\n", + "hapi(): file directory = /tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi\n", + "hapi(): Reading https://cdaweb.gsfc.nasa.gov/hapi/info?id=OMNI2_H0_MRG1HR\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n", + " InsecureRequestWarning)\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "hapi(): Writing OMNI2_H0_MRG1HR___.json \n", + "hapi(): Writing OMNI2_H0_MRG1HR___.pkl \n", + "hapi(): Reading https://cdaweb.gsfc.nasa.gov/hapi/capabilities\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n", + " InsecureRequestWarning)\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "hapi(): Writing https://cdaweb.gsfc.nasa.gov/hapi/data?id=OMNI2_H0_MRG1HR¶meters=DST1800&time.min=2003-09-01T00:00:00Z&time.max=2003-12-01T00:00:00Z&format=binary to OMNI2_H0_MRG1HR_DST1800_20030901T000000_20031201T000000.bin\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n", + " InsecureRequestWarning)\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "hapi(): Reading and parsing OMNI2_H0_MRG1HR_DST1800_20030901T000000_20031201T000000.bin\n", + "hapi(): Writing /tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi/OMNI2_H0_MRG1HR_DST1800_20030901T000000_20031201T000000.pkl\n", + "hapi(): Writing /tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi/OMNI2_H0_MRG1HR_DST1800_20030901T000000_20031201T000000.npy\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "{'HAPI': '2.0',\n", + " 'contact': 'NASA-SPDF-Support@nasa.onmicrosoft.com',\n", + " 'parameters': [{'fill': None,\n", + " 'length': 24,\n", + " 'name': 'Time',\n", + " 'type': 'isotime',\n", + " 'units': 'UTC'},\n", + " {'description': 'Dst - 1-hour Dst index (1963/001-2014/366), Provisional Dst (2015/001-2016/366), Quick-look Dst (2017/001-2021/116), from WDC Kyoto',\n", + " 'fill': '99999',\n", + " 'name': 'DST1800',\n", + " 'type': 'integer',\n", + " 'units': 'nT'}],\n", + " 'resourceURL': 'https://cdaweb.gsfc.nasa.gov/misc/NotesO.html#OMNI2_H0_MRG1HR',\n", + " 'startDate': '1970-01-01T00:00:00Z',\n", + " 'status': {'code': 1200, 'message': 'OK'},\n", + " 'stopDate': '2021-05-11T14:00:00Z',\n", + " 'x_cacheDir': '/tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi',\n", + " 'x_dataFile': '/tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi/OMNI2_H0_MRG1HR_DST1800_20030901T000000_20031201T000000.bin',\n", + " 'x_dataFileParsed': '/tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi/OMNI2_H0_MRG1HR_DST1800_20030901T000000_20031201T000000.npy',\n", + " 'x_dataset': 'OMNI2_H0_MRG1HR',\n", + " 'x_downloadTime': 1.0933701992034912,\n", + " 'x_metaFile': '/tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi/OMNI2_H0_MRG1HR___.json',\n", + " 'x_metaFileParsed': '/tmp/hapi-data/cdaweb.gsfc.nasa.gov_hapi/OMNI2_H0_MRG1HR___.pkl',\n", + " 'x_parameters': 'DST1800',\n", + " 'x_readTime': 0.00011515617370605469,\n", + " 'x_requestDate': '2021-05-26T11:13:15',\n", + " 'x_server': 'https://cdaweb.gsfc.nasa.gov/hapi',\n", + " 'x_time.max': '2003-12-01T00:00:00Z',\n", + " 'x_time.min': '2003-09-01T00:00:00Z',\n", + " 'x_totalTime': 2.0009572505950928}" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "dateTimes = \n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "array([datetime.datetime(2003, 9, 1, 0, 30, tzinfo=),\n", + " datetime.datetime(2003, 9, 1, 1, 30, tzinfo=),\n", + " datetime.datetime(2003, 9, 1, 2, 30, tzinfo=), ...,\n", + " datetime.datetime(2003, 11, 30, 21, 30, tzinfo=),\n", + " datetime.datetime(2003, 11, 30, 22, 30, tzinfo=),\n", + " datetime.datetime(2003, 11, 30, 23, 30, tzinfo=)],\n", + " dtype=object)" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "DST1800 =\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "array([datetime.datetime(2003, 9, 1, 0, 30, tzinfo=),\n", + " datetime.datetime(2003, 9, 1, 1, 30, tzinfo=),\n", + " datetime.datetime(2003, 9, 1, 2, 30, tzinfo=), ...,\n", + " datetime.datetime(2003, 11, 30, 21, 30, tzinfo=),\n", + " datetime.datetime(2003, 11, 30, 22, 30, tzinfo=),\n", + " datetime.datetime(2003, 11, 30, 23, 30, tzinfo=)],\n", + " dtype=object)" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k0Z6fVPQW6Di" + }, + "source": [ + "## SSCWeb data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "rjXkzg6WW6Dj", + "outputId": "432a76a7-b7b5-4ba1-a581-7a2fe21ed79d" + }, + "source": [ + "from hapiclient import hapi\n", + "from hapiclient import hapiplot\n", + "\n", + "server = 'http://hapi-server.org/servers/SSCWeb/hapi'\n", + "dataset = 'ace'\n", + "start = '2001-01-01T05:00:00'\n", + "stop = '2001-01-01T06:00:00'\n", + "parameters = 'X_GSE,Y_GSE,Z_GSE'\n", + "opts = {'logging': True, 'usecache': False}\n", + "\n", + "# Get parameter data. See section 5 for for information on getting available datasets and parameters\n", + "data, meta = hapi(server, dataset, parameters, start, stop, **opts)\n", + "\n", + "# Plot all parameters. See section 3 and 4 for information\n", + "# on extracting data and using other plotting functions.\n", + "hapiplot(data, meta)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "hapi(): Running hapi.py version 0.1.0\n", + "hapi(): hapi(): file directory = hapi-server.org_servers_SSCWeb_hapi\n", + "hapi(): Reading http://hapi-server.org/servers/SSCWeb/hapi/info?id=ace\n", + "hapi(): Writing ace.json \n", + "hapi(): Writing ace.pkl \n", + "hapi(): Reading http://hapi-server.org/servers/SSCWeb/hapi/capabilities\n", + "hapi(): Writing http://hapi-server.org/servers/SSCWeb/hapi/data?id=ace¶meters=X_GSE,Y_GSE,Z_GSE&time.min=2001-01-01T05:00:00&time.max=2001-01-01T06:00:00&format=binary to ace_X_GSE-Y_GSE-Z_GSE_20010101T050000_20010101T060000.bin\n", + "hapi(): Reading ace_X_GSE-Y_GSE-Z_GSE_20010101T050000_20010101T060000.bin\n", + "hapi(): Writing hapi-server.org_servers_SSCWeb_hapi/ace_X_GSE-Y_GSE-Z_GSE_20010101T050000_20010101T060000.pkl\n", + "hapi(): Writing hapi-server.org_servers_SSCWeb_hapi/ace_X_GSE-Y_GSE-Z_GSE_20010101T050000_20010101T060000.npy\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/kAAAHACAYAAAD5r6hAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XmYXFWZ+PHvyxocBZ2IK4EGkcVlREURRFZZhogsLsC4gKMsLiCiM0YBQQY1+hsHFWcEcQk6IqCIgWlBlLAJKIqCo4CI0BJQFkFAdgjv749zaigqtzrVXZ2ku/L9PE89RZ17zrmnqm4Xee/ZIjORJEmSJElT33JLuwGSJEmSJGliGORLkiRJkjQgDPIlSZIkSRoQBvmSJEmSJA0Ig3xJkiRJkgaEQb4kSZIkSQPCIF+SJEmSpAFhkC9JkiRJ0oAwyJckSZIkaUAY5EuSJEmSNCAM8iVJkiRJGhAG+ZIkSZIkDQiDfElahIgYioiMiDlLuy1LSkTMqe95aGm3pV1EnB8RubTbIWlqi4gD6m/cnhNU3y0Rcc1E1DVRImJafY9nL+22SFqyDPIlaYJFxD71H1b7dDl+ZD2+1RJu1zMjYkFEfKHh2Jtqm3Zfkm2SWiLi+Ih4JCKmL+22TFUR8cOIuD0ilm9L26Mt/ZGI+EtEXBUR34yItzXUsUpE/EtE/Cwi7o6IhyPizxHxi4g4NiJe0+Xcy0XEmyPiexFxU0Q8GBH31nMdHxGbtuX9Uv29eVeXuubV4z/ucny/evz4sX9KEyMivlo/m6curTZIUjcrLO0GSJKWmF0oN3dPbzi2G/AA8MMl2qKxezvwpKXdCE2siFiOcn1emJl3LO32TEURsRqwNfDNzFxQ074K/DNwP/A/wAjwFGAd4PXAa4BvttXxFOAi4CXAn4HvArcBzwTWAw6o5S/qOPdzat5NgXuAHwF/AJYHng/8E7BfRLw7M48Dzq11bQt8paOuabWeBF4dEStn5kMdb3eb+nzu2D6liVFvouwMnJeZdy2NNvToIWBD4N6l3RBJS5ZBviQtO3YD7gAubE+MiJWAmcA5mXnf0mhYrzLzxqXdBi0Wm1ICyaOXdkOmsNcBK1Jv4tWRQv8M/BHYLDP/1J65/t1v2VHHBykB/g+AXTPzkY4yTwM26Ej7O+Bs4MXAScB7OwPfegPiX4BWr/d5lCB+64b3sRkwDfgO8Kb6+ryOPFvV8p3pS8rmwOo03zCdNDIzgUk1hUDSkuFwfUkagzo//+Q65PXBOoT1dW3Hzwe+Xl9+vQ4pbT2GImIEOKIeP6/9eFsdrfnw60TEIRFxTT3XTRFxTESsOo52r0bp/Tqz1cvXZltgVbr8gzUi9o+I/61tuDUivlzr68y3dT12VUTcExEPRMRvIuKI2jvXmf//pi1ExN4R8ata5raI+FpEPKuhzJjn5EfEayLizPr5PRRl7uxPI+KIhrxPioiPRMQVEXFfHW58aUTs1ZB3q9r+IyPilRExHBF31rQNIuKu+l4ab6hHxHE178yO9A3qNTC/tvfWiDgpItZvqKP9WjkwIn5dP8Pze/xsto8ylPuv9fv9XUR8sukai4ifRMSjEbFyfc/X1vZ9pS3PUyPiCxFxc63v6og4OCKeX9v5lc56q90pQdv32+raKCJOiYiRep7bI+Ly+jewfHvhiFghIt4XZYj5PRFxf0T8MiLeExHRkXfdVlsiYv2I+E6t+7GI2Dwifl/b/rQun9lhtfz+HekzIuK/IuL62t47ImJuRLy8oY6jax2bR8TbIuKyeq1d15Zn1yjD1m+p9d1cr/8DRvkM7wVaQ9w3q8/f7QzwATLz4cz8UUdyq8yXOgP8WuavmXlpR/KHKAH+BcDbmnq2M/PuzDwMOKa+vgO4EnhmRLywI3url/7jlGtim/aDEfEiyg2hX2fm7R3Hnh4Rn6nX8YP1b/CciHhCHZ3qZ/2z+jd/Z73u1h6lSOt6ndtQ11PqNdr6+702Ig7pct59I+L0iLihtvfuiLgoIvbokv+nNd8qETE7Iv5Yz/H7iPhoRKzYkd85+dIyyp58SerdWsBlwPWUIa5/D+wBzI2I12bmecAc4C7K0OO5wBVt5e8CPgfsSulBO5EyfLabY4AtgFNrXTsABwOviYjNM/PBVsYo8/+/DpyYmfs01DUTWAn4XsOx3YBHgTMbjn2mnvdM4BxKz9u+wLp0/OMb+DCll+8SYJjSG/dq4Ehgq/oZdd5gAPgAsD1wCqVHcHPgHbXMJp3/kB+LiNixtuUe4AzgZsr3tiHwHkog0cr7VGAe8FLgl8DXKDfDdwBOiogX1kCl06bAR4Cf1DJPr+c7BdgP+Ec6PtuIWBl4M3ArbVMkanu/R+mRPRO4DliDElTMjIitM/OXDW34PGXo9TClF7bpc+78bN4LHEsJDL8D3E75fj8C7Fyvsbsbip4ObFTbfTplWDcR8SRKz+pGlM/vm8DTKDe1OnuMO+0K/Dwzb6p1vRS4tL6PMyh/J6tShn6/t7axNSR9pfq+X0vptfwWZZjyNsB/Aq8E9mk453qUv+ergP+mTAP5G/AN4ChgT+BLDeXeVus/pZUQERvXz+NplGv4NEpP727AjhGxc2ae01DXh2u7z6Rce0+u9b2ntv3P9f3/BXgGpZd9b+C49koiYhXKdTrc9rvQmvawXsN5uxlPmX3r879l5mOjZewYdj+Pcq1sC/y2LX1b4KrM/G1E/Lq+PrzjOHQM1Y+I51GuvxnA+ZRrYlXKsPofRcQ7MvMbDc3ai/I3elqt8+WUv82tI+JVmXl9Q5ldgUsz888d6dNqHU+jTI9Iyt/uZyNixcz8dEf+LwM/r+29hfLbMRM4OSLWzcxPNJw7KH93L6T8ViygXGefAF4GvLGhjKRlTWb68OHDh49RHsAQ5R9rCRzRcWyHmv6DtrR9ato+Xeo7sh7fqsvxOfX4X4C12tKXo/xDNIHDO8q0zjmnS53foQRz0zrSl6P84/LHXdpwI7BmW/oKlOH+Cbyyo8w6QDSc+99q/j26fA4PAy/tOHZMPfbVjvTzqaNQe/zuWp/XSxqOPb3Le/7XjvRplMDtMWCjtvSt2q6L/Rvqb80r/m7DsTfVY59tS3sa8Nf6vb+gI/8L6/f3yy5tvhlYewyfyzr1c78LWK/j2Jdrnf/Vkf6Tmv4rYHpDna2e1/9uvw4oN8fuqMe+0lDuJfXYrLa0z9e0mQ35/76j/qNr3s8By7elL9/2+cxsS1+37Xs7qqH+Net3/dNRvtNT2tJWpNz4ewDYvCP/GpRA/SZgpYY239vl2ryy1vf0hmNNabvU+vbseB/38PgIib3qe1/ob7StzK41/4PAF4GdgGeNkn/tmv+h9vfX4zW4U6ttbWlPAR4BvlhfH1NfP7ktz9xabqeO+n5KDXgbrper6mc9vS39gLbr4LUdZT5c04cb2v3yeuxDHem3tH3W09rSn1PPfTuwXEeZ5zXUP42y5sFDwDMa3mNSboqs2pb+JODyeuxNHXUlcPZYvhsfPnxM/cdSb4APHz58TPYHjwf5I7QFEW3H/wj8pe31PkxMkH94w7F16j9kb+hIX43Si/7shjLTKD2U32k4tnk913u7tOFdDWXeUY+9r8fPb3rN/7Uun8NXG8qsRglAHwBWbks/n/EF+ev10MZHKb3JTcdbgehn2tK2qmm/GqXe39V/rP99R3qrl+8f2tLe3/RdtB1v3fh4QVta63t6/xiv6SPoHuROpwQl9wErtqW3gvyFAu96fKR+hjNGOV9TkN+6DtZvS2sF+dss4n0sT7kxchPNf5uta++ktrRWkH8zXQJTSi/zE9pU04+jI8AE3lDTPtWlrg/W49u3pbWC/P/XpcyVlAB9tR6/zzn1Olu1I/21lBsQ2fa4GziLshjecg11faDmaS/zJ8rNm86bGJvV4zeN5fqrZZ9MCeD/2moHpRc7gd3r69e3f95t3/fDPDHw36Tm+2aXc+1Rj/9zW1oryG8K5Fek3OB8jI6bHG3f3fM60ltB/hoN9Z1Sj63b42fzTzX/mzvSW0H+mxrK7FiPndWWZpDvw8cy+nC4viT17opsHm4+n9LDN9Eu6EzIzOsjYj4wFBFPzTr/Ncuw6qah1VCGwj+Z5jn3C82F7vCLhrT59fkJc5ajLMD1fsrQ0fUovXLt86Gf2+UcTe/z7oi4gjLMe0OeOO2h/ZxPpUxh6PS5+tl8i/IefxYRp1CG816cdVh4m1dQAoiMiCMb6mvNdd2w4dhlTW2rTqQMo90T+K/a5mdSRoD8KjN/3Za3dQ29pEsbWkOoN6T0TPbahiYvq8/zOg9k5h0RcSUlgFuPJw6lbjxXnb++FuXm0/zO45QbBN3sDlydmb9rSzsZeB9wZkR8lzLP/OJceOj0hpTF3G4FDu+Yft/yIM3f2xWZ+XCXNs2hTF3YG/go/N8Uiz0owVz7LhSt723tLt9bay2FDSlTXtp1+96+BXwauKpetxdQ3v9fOjNGWfNhZ+DczLyn/Vhm/jgi1qXczNuC8r2/mhIQ7gi8PSJe3/45ZOYxEfFlYDvKNfDS+vwW4C0RcURmHtU6fatYl/fRVWbeGxGX1bpfRvmt2abW1fpNuJASaG9DmYbyMsr3/ZPMbF8xvvUdTO/yHTy7PjddB02/P49ExCWU73sjykielt2B/83MPzTUdWvDbwt0/81cG/hXyhSENYBVOsr1/JtJvQFK+b4kLeMM8iWpd922SnqUxbOQ6a1d0m+hBFSt3u5F2Y3S8zXccGxX4LLMvLlL2ab6H63P7Xtxr0gJGF8J/IbSc3U7pacOSk/uyl3OMdr7hPI+u3kqjy9k2G4OcFdmfi/KwogfpKw0vn9t7+XAR/Lxhcdae7O/oj66efIo7WzyDcp0hb2pQT4lWFqBcgOgXasN+zK6sbahSesz7ZxTTEd65x7gC7J5jYRWfd2+y8b0Oo/6xZQbIf8nMy+NiC0oAfabKVsnEhHXAEdmZms+fOszW5/m66BlrJ/ZaZQ58W+LiMOyzDXfhfJ5/HvHzb5WGxoXSxtPGzLzMxFxG/Buyk2sD1BuQJ0H/Es+cV2GLSlD0pvW26C2/cL6IMqdkB0o198OlHUjvthR5j7Kjb/v1zIrUXq+jwGOjIjTM/N/KT38AM+IiJVGuWnSzbmUIH9bSpC/LXBl1m0UM/OuerOvNQ+/cT4+j38H/1gf3TR9Bz3//kTEepQbBR9vLDH6/yPgib+Z61N65lelBO1nUUZvLKCMNnkLzb+Zj1F+W58gMx+MiHsY/fdS0jLC1fUlafJ6Zpf01qrz3Xru/088vp/zvOxYRC0iNqLMqZ2IbaB2oQT4J2bmizNzv8w8NDOPBI5fRNlxv8/MHMnMaHiMtOUZzsxtKL1o21IClRcC/xMRL+g4xzFd6ms9mrb86tqLWXv15gGvjIjW1mN7U25+nNSRvdWGlyyiDZ03B0ZtQxetcy20g0H17I58vdbX7bvslr5bfV7oGszMizNzJiWw3pxyI+DZwLejbA/Xft7vLOIze37DuUf73u6j7Pu+Bo8vMLl3fe78/FttmLmINjQtojZaG+Zk5iaUAPZ1lIU1twZ+GBHT27LuRgn8zuhWV0e9mZlnAx+rSaOuPF/LPJyZX6AsAhq1HWTmDdRpD5TvaKxaI0m2qe/pH1h4W7zzKKNbpre1tTPIb30H+y/iO3h3QxvG8vuze32eiN/M1paCb8nMbTLz/Zl5eP3N7Hx/7ZajLOr4BFF2MFmV3v9mJQ0wg3xJmnitXr7lx3m8ZcvOhIhYh7J69Eg2bFXVYAtKkND0j9KuAdY4rFufT2s4ttD7WNTxKFv0bUQZan11f00rMvO+zJyXmYcAn6QEJq1ev8sogdJrJuJcHebU573rjZV/oMyb7eyN+2l9Xhxt6PSr+rxV54GI+HtKG++nrCmwSJn5V+oijRExoyFLtwBwN2B+Zl4+St0P1YD/MEqPdlBuKkGZSvA3YNPoslVhH+bU573rFIvtKQsf/qYj32L93rJsWzecme+k7FjwdOrnWXvld6UM5b9tjFX/rT43znEYQ5kT6vNh0WW+REud8tDuUuqChZRRBcHCU0jOq+k7UKYa3Mfjn3lLP99B0+/Pijy+3kD7VKHdKFNSrhzHeTq11oZoGoEx5t9Myt9y8PjftqRlmEG+JE281jZUa47zeMv7I2Kt1ouIWA74f5Tf7q+3Z4yI1aLsr/7sjjp2pwSvC+3nXI9dlZnXLqIdvRipz1t1tGsdytzi0bytbpnW7kjKsNNv5xO33RqTiNi2bi/WqdV7dz9ADZC+BWwcEYc3BYwR8bwYfe/sbr5HGYb7Vh7fym1OQ76vU4b7HhERr2w4/3JtPdg9q9fF+h3J36QMIX5/w3v6BGVY8zeyYa/0UXyDcuPqk+3BXkSsCRzU0K5nAa+i4SZTRGwREas2nKPze3uEMtR8DeBztTezs67nRETTXOxFuRC4gfJ3cgBlisWchnynU67/gyJih6aKImKzprZ1ExE7dl6D9TN9Rn15f31+JWXedtNnuFOU/d+bruWnUNbPgDqMv6a/u+naq8deQFlkEMrq7y3/TpmiszUwp96gW+h8EfFxOtbPqH/bF1NWh59FuQF6YUfxi2r6rJrvos7rMjN/QrlRt1dEvLVL+zfqGAHRslNEvLYj7RDKzdSzM/OWWn4NylSeibgpCuWaCToC9ojYmbJN42iObP/7iLJ9ZWukyNebi0haljgnX5Im3qWUf4QfXHtFW3M+j61D5s+jBN6fiogXUVaLJjOP7qjnYuCKuvDW3ZSerJdQtkr6TEfe3Sj/uDuRJ+4JvitwSWY+Yd5pXYzrRZSVoidCa0/3QyLixZTepDUpw4yHGf2GxlnAxRFxKmUu+Ob1MUL5h30/PktZpPD8Wt/DlC2wtqHsinByW973UfZhP4py4+EnlO/uOZR5uK+gbEN2w1gakJkPRMR3gHcC76Hc5FlofYQsC969kRJE/DQizqX0VD9G+fw2pYzKGEuwuAJlJMQC2v6fn5l/iIgPUlaxv6J+9n+hBGqbUBb2+8hY3icwm9LD/lZgw4j4MWU48pspc453re+lZVfKDaumnsx/pexTfj5ldfj7KNfrPwJ38njvMZS5+P8AvBfYJSLmUeaKP5PyfW5G2RJtTCNCMjMj4hu1/kMpUyy+3ZDvoYjYnbI429kRcTGl9/cByvf2Csq0mNUpI1N68V3gb/UaHKHcPHkNsDElmG0NaR9tNM4LKDcF74yIiyh/n49SgteZlJtolwBfaiszE/iviLihHptPmRe+HuX3ZwXgP9rXBMjM++rNjdMoayfsEhE/Av5Q270u5e9tVcrNkk7nUnYBeDFlfZDOxQPvqWtovLItf5M96rFvRsQHKPvP313f70aUv+GX8vhN1pYzgB9ExGmUv+2XU0Zt3A4c2JZvV0pQ3rj2wTh8kTLv/oz6+3Ar5TrejrLl6Zu7lHuY8r38trb5Mcp1MASclpmnTlD7JE1lOQmW+Pfhw4ePyfzg8S305nQ5fj4d27pRVq6+lLIVWWsbqqG242/l8UAg28vz+LZo61AWjLuGEhzcTNkLfNWGNuzT2UZKcJHAIQ35/6Uee1mX99Rqw1DDsa3qsSM70mdQesNvru/rt5RgbYWa//yO/EfW9K1q+1ufx+2UGxZN2wEu9Fkv4rt7MyUw+339Lu6h9Dp+Ali9If9KlGD/EkqA8BBlGPq5lF7I6Yv6HLq0o7VVYVJu9izqevtibfODtc3XUHrfd+31e6rHW5/9o12O7wj8iDKC4KF6ztk0bN1GWSG/sZ62PE+rbf9Tre+a+rm19pf/97a8P6zfddPWdzvW93Z1/R7urXV9HlizIf9ylDnz8yg3AR6u1+FFlJsVa7TlbQ2TXmg7v4Z616YEUQmcvoi8z6SMWvkt5SbfvfXz/A4lmFu+LW9rG7bNu9T1Hsqid9fXuu4Efkn5u23fOu53lCkETXWsTrmxdDLlps1dlBsVt9Xr+QDatkisZTYAPkS58XYd5eZK62/gNDr2pm/4Dvag3HC4qZa7v36HJwCv6lKu9TuVwOwueWa35XnpKG1YjbLWwK/q539//QzPBN4FrNKWt7WF3p6UAP5nNf9fKWsPrNNR97mUxfgW2nawHr8FuGYR7X9VR/oWlN+0uyh/5xdSboy2tsOb1ZH/p5TfhFXqtfZHyrX+B8qNqM7v0y30fPhYRh+ROeZdTyRJi1FEzKEELGtn2wJy46jnk5QAZ50sC2S1H7sEeG5mrtVYeAmIstXVEcDWmXn+0mqHFr+IeDdld4F3ZeZX65Du2yn7mr9z6bZuaqrD538LfCwz/21pt2eQtY3I+lpm7r8U2/FTYKPM7Hk0j6Rlk3PyJWlw7UbZjqozwH82XeZCS/2IiOc0pK3F48PdW9MUXgesiNdgPyZy4UyNbmfKqBg/a0lTgnPyJWlAZWbjYmOZ+We8yavFY25dc++XlCHIa1MC+lUo+7vfApCZ36JM7dA4ZdmSr2lbPk2wLNtWNm1dKUmTkkG+JEmaKN+gzD9/I2WhtXspa1Mcm5nfX5oNkyRpWeGcfEmSJEmSBoTDNSVJkiRJGhAG+ZIkSZIkDQiDfEmS1LeI2CciMiK2WtptkSRpWWaQL0mSlqiI+I96Q+Dzo+RZKyLujoi/RsSMcZ5nxYh4e0R8PyLmR8QDEXF/RNwQEadHxLsi4u8ayi0fEftGxAURcWdEPBIRt0XEryPiKxHx+o78W9X3M+pjPO9BkqSxcnV9SZK0pH0EeC1wYEQMZ+Y57QcjYjnKSv2rAv+UmfPHeoKI2AA4DXgBZTu/ecANwKPAc4EtgF2BTwGrt5VbHvgfYMdabhi4Cfh74HnAPwEbAGc0nPaPwJyxtlWSpIlkkC9JkpaozHwoIt4C/ByYExEvzsw72rL8CyUIPykzvz3W+iPi2cC5wHOAY4GPZua9Dfm2A/5fR/JelAD/SmDLzLy7o8yTgE26nHokM48ca3slSZpIDteXJGkSq3PdT4uI6+tw83si4uKIeOsoZf4+Ij4REb+pw9PvjogrI2J25/D0mvdTEXF1rf/uiDg3IrZfnO8rM/8X+CjwbOCEtvZsBBwF3Ai8Z5zVf5IS4J+UmQc1Bfi1DT8CNu5I3qw+z+kM8GuZ+zPzvHG2S5Kkxc6efEmSJrcvAVcBFwJ/BqYDOwHfjIj1M/Pw9swRsTZwHrAWcHktvxywHvAB4Djgvpp3LeB8YAi4CDgb+DvgdcDZEbF/Zp7A4nNMfS+7RcQ/AycB/03598nbm4LsRak97XvVlx9fVP7MfLQjqTWiYL2xnluSpMnAIF+SpMntRZn5h/aEiFgJOAuYFRHHZebNbYf/mxLgfzQzP9VR7ulAe6/2iTXvXpl5clu+p1KC/y9ExBmZeetEvqGWzMyI2Bv4X+DzwHbAC4HPZOYF46x2Y2Bl4KbMvHYc5b8HfBg4ICKeApwOXJ6Zf+yh7FBEHNnl2DXtn7EkSYtLZLrYqyRJU01E7E5ZWG7vzPxGTXs58AvgCuDlmfnYKOVfUvN9NzPf1HB8F+D7wHsz8796aM8+wNeBrTPz/DG+lzcBp9aXVwCbZObDY6mjra43A6cAP8vMV3Vp51BH8vcz84qOOj4PPKstz52U0RRfy8wzO+rcijJ6YjRzM3PX3t6FJEnjZ0++JEmTWESsSelZ3hZYE1ilI8tz2/67FdT+cLQAv9q0Pq/Wpfe5teL8hr23dnwy8zsRcRnwSsoIhHEF+FW0qu1yfB9gy460EcrNhVZ7To2I04Gtgc2Bl9bnXYFdI+IbwD65cE/JBZm5VR9tlySpbwb5kiRNUhGxDnAZ8DTKnPlzgLuBBZTe6L0pQ9Nbnlqf24fvdzO9Pm9XH908ufcW9+WBjufx+nN9fm7TwfYgPCKOBg7tku8Ryud9Ts27PPAG4GvA2ynD+L/fZ1slSZpwBvmSJE1eh1CC8Xdk5pz2AxGxFyXIb3dXfW4McDu0FrV7f2Z+oZ9GTjK/AB4CZkTE8zPz9xNRaWYuAE6NiBcDhwHbYJAvSZqE3EJPkqTJa936fFrDsc4h5wA/rc87RMSi/h/fyvua8TRsssrM+4Fv15cfWwyn+Ft9jlFzSZK0lBjkS5I0eY3U563aEyNiB+BdnZkz83LgEmAjyjx+OspNj4hpNe8vKFMAdq/b1y0kIl4cEc/oo/1Ly6HAn4C3RsQxEfF3XfKt1pkQEXtFxHZNN0ki4lnAvvXlhRPWWkmSJpDD9SVJmrz+C3gH8J2IOI0y1/5FwI6U1ej3aCjzVsr2d5+MiDfU/w7g+cD2wAY8fvPgn4B5wFcj4iDgZ5Qh/2sA/1DPtSlw24S/s8UoM/8UEdtStsM7GNg7IuYB1wOPAc8EXk35TG4DrmkrvgnwfuCWiPgJcENNXxuYSVn4cC7w3YZTj7aFHsDnMvOuUY5LktQ3g3xJkiapzPx1RGwNHA3sRPn/9pXA7pRgfKEgPzNviIiXAf9KWQ3+fcCDlMD+s7QF7Jl5U91270DKonJvAZYHbgGuAo6l7GE/5WTmNRGxEbAX5b1tCryOsur+bZTV9D8NnJKZ97YV/Szwe+C1lBsdOwDTgDsoN0xOAk5qWFkfYC3giFGaNYfH102QJGmxiOb/R0mSJPWu7j//dWDrzDx/6bZGkqRll3PyJUmSJEkaEAb5kiRJkiQNCOfkS5KkSa1OBRjqIesVmene9ZKkZZpBviRJmghXAB/n8ZX7J9I+wJY95DsRMMiXJC3TXHhPkiRJkqQB4Zx8SZIkSZIGhEG+JEmSJEkDwiBfkiRJkqQBYZAvSZIkSdKAMMiXJEmSJGlAGORLkiRJkjQgVljaDVD/IuIGYFUWz97EkiRJkqRmQ8A9mbn20m5Ii0H+YFgVmLa0G9FkxowZGwDMnz//mqXdFsnrUZON16QmE69HTSZej5pMFnE9Tro4zCB/MIwAZObLl3I7FjJ37tzLAXbZZZdJ1zYte7weNdl4TWoy8XrUZOL1qMlktOsxIi5f8i0anXPyJUmSJEkaEAb5kiRJkiQNCIN8SZIkSZIGhEG+JEmSJEkDwoX3tFgMzRpeAdjuH9eIZzz0WCz3/lnDBwO/A84ZmT1zwVJuniRJkiQNJIN8TaihWcOrA/sB+wMzzrpp+dahY+rzjUMBwYuGAAAgAElEQVSzho8HThiZPfP2pdBESZIkSRpYU264fkRMj4h3RcTpEXFdRDwQEXdHxE8i4p0R0fieotg7Is6PiDtruRsi4tSIWG+MbdgsIn5Q67k/In4dEQdHxPI9lI2I+FFEZH0MzI2WoVnDmwFXA0cDM7pkWxP4BHD10KzhTZdU2yRJkiRpWTDlgnzgTcAJwCbAz4DPAacBLwK+ApwaEdFeICKmAWcAc4BnASfVchcCGwM9B/kRsUsttwVwOvCfwEqUnuqTe6jifcDWwIO9nnMqqAH+ucD0HotMB+YZ6EuSJEnSxJmKvcjXAq8HhjPzsVZiRHwUuAx4A7A7JfBv+SzwOuBTwGHt5WrZFXs5cUSsSrnBsADYKjN/UdMPB+YBb4yIPTOzMdiPiPWBTwP/DuwJrNXLeSe7OkT/DGDaGItOA84cmjW8oUP3JUmSJKl/U64nPzPnZeaZnYF6Zt4CHFdfbtVKj4jnAQcAPwcO7SxXyz7S4+nfCKwOnNwK8Gv5B4HD6st3NxWsw/K/CdwAHNHj+aaK/ei9B7/TdGDfCWyLJEmSJC2zplyQvwitYP3RtrS9KO/zRGDViHhrRHwkIvaLiHXHWP829fnshmMXAvcDm0XEyg3HDwNeCuydmQ+N8byTVl1Ff/8+qzlgaNbwItczkCRJkiSNbioO129Ue8rfXl+2B+GvqM+rAX/giT3OGRFfAg7KzF62dVu/Pl/beSAzH42IG4AXAutQFqBrte0VwKHA7PYRAANiO7ovsterGcD2wFn9N0eSJEmSll2RmUu7DRMiIv4d+CDwg8yc2ZZ+KfAqyjz6HwMfAkaAVwLHA+sCH8/MI3s4x7XA84HnZ+Z1DccvBjYDNsvMS2vaKsCvgIeAjVtTAyJihDInf8XMfLSzri7nv7zLoQ1mzJjBsccee00v9Uyks+fHM866afk1+q1npxkLbtphjbxtItokjWKD+rzE/1akLrwmNZl4PWoy8XrUZNL1ejzwwAM3mD9//jWZ+fIl3KauBmK4fkQcRAnwrwHe1nG4NQz8z8BumfmbzLw3M+dR5tg/BhwSEStNRFPqc/udk89Qevb3HsPc/ynjoceatywcqwcXTEw9kiRJkrQsm/I9+RHxXuCLwFXAtnUBvvbjP6QMBf9KZi60wFtEXAc8D9goM69cxLl+Ttlyb+PMXKhXPSJ+Qxmu/4LMvDoitgTOA47MzKM68o4wxp78Udp1OcDSuHs0NGv4YMr2gf06eGT2zM9PQD1SV3Pnzr0cYJdddpk0d1q1bPOa1GTi9ajJxOtRk8lo1+PSjMW6mdK9pxFxMCXA/w2wdWeAX/2uPt/VpZq/1udVejhlq671GtqyArA2ZdG/62vySym9+x+PiGx/8Pj2eY/UtI16OP9k9LtFZ+nJQuscSJIkSZLGZsouvBcRHwZmA1cA22XmX7pkPRc4EHhRQx0rU+bYQ5mnvyjzgLcAOwLf7ji2BfAk4MK21fN/A3y1S117AE8GvkYZ3n9HD+efjH4EzKe/xfduBM6ZmOZIkiRJ0rJrSvbkR8ThlAD/csoQ/W4BPpQV268HdoiI7TqOHU5Zdf+C9lEAEbFaRGwQEc/uyP9d4C/AnhGxcVv+acDR9eWXWumZ+ePMfFfTg8eD+v1r2vxe3/9kMjJ75qOUBQz7cfzI7Jm97G4gSZIkSRrFlOvJj4i9gaMoq+VfBBwUEZ3ZRjJzDkBmPlzLnAOcFRGnA3+kbK23BXA7sF9H+d2ArwMnAvu0EjPznojYlxLsnx8RJwN3Aq+nbK/3XeCUiXqvU8iXgQ/wxO0Je3UHcMLENkeSJEmSlk1TLsinzHuHsmr+wV3yXADMab3IzJ/UnvcjgK2BpwK3UoLTf8vMm3o9eWZ+vy6odyjwBmAacB1wCPCFnOorGY7DyOyZtw/NGt6ZMp1h2hiKPgjsPDJ75u2Lp2WSJEmStGyZckF+3c/+yHGUu4oyD76XvHNou0nQcPxiYKextqGjjqF+yk82I7NnXjo0a3hb4Ax669G/gxLgX7p4WyZJkiRJy44pOSdfk9PI7JmXABtSRjl0W2PgRuCjwIYG+JIkSZI0saZcT74mtzr0/pNDs4Y/DWy/04wFX35wQSw370/LfYayTd45LrInSZIkSYuHQb4WixrInzV37tzbIPnaQTt/fmm3SZIkSZIGncP1JUmSJEkaEAb5kiRJkiQNCIN8SZIkSZIGhEG+JEmSJEkDwiBfkiRJkqQBYZAvSZIkSdKAMMiXJEmSJGlAGORLkiRJkjQgDPIlSZIkSRoQBvmSJEmSJA0Ig3xJkiRJkgaEQb4kSZIkSQPCIF+SJEmSpAFhkC9JkiRJ0oAwyJckSZIkaUAY5EuSJEmSNCAM8iVJkiRJGhAG+ZIkSZIkDQiDfEmSJEmSBoRBviRJkiRJA8IgX5IkSZKkAWGQL0mSJEnSgDDIlyRJkiRpQBjkS5IkSZI0IAzyJUmSJEkaEAb5kiRJkiQNCIN8SZIkSZIGhEG+JEmSJEkDwiBfkiRJkqQBYZAvSZIkSdKAMMiXJEmSJGlAGORLkiRJkjQgDPIlSZIkSRoQBvmSJEmSJA0Ig3xJkiRJkgaEQb4kSZIkSQPCIF+SJEmSpAFhkC9JkiRJ0oAwyJckSZIkaUAY5EuSJEmSNCAM8iVJkiRJGhAG+ZIkSZIkDQiDfEmSJEmSBoRBviRJkiRJA8IgX5IkSZKkAWGQL0mSJEnSgDDIlyRJkiRpQBjkS5IkSZI0IAzyJUmSJEkaEAb5kiRJkiQNCIN8SZIkSZIGxApLuwGStCwYmjW8ArAdsD7wZOBe4HfAOSOzZy5Ymm2TJEnS4DDIl6TFaGjW8OrAfsD+wIyGLDcOzRo+HjhhZPbM25do4yRJkjRwHK4vSYvJ0KzhzYCrgaNpDvAB1gQ+AVw9NGt40yXVNkmSJA2mKRfkR8T0iHhXRJweEddFxAMRcXdE/CQi3hkRje8pir0j4vyIuLOWuyEiTo2I9cbYhs0i4ge1nvsj4tcRcXBELN+Q98UR8ZWI+FVE3B4RD0XE/Ij4cUTsHhEx3s9C0uRVA/xzgek9FpkOzDPQlyRJUj+mXJAPvAk4AdgE+BnwOeA04EXAV4BTOwPniJgGnAHMAZ4FnFTLXQhsDPQc5EfELrXcFsDpwH8CKwHHACc3FHk5sCtwM3Aq8FngR8BLaru/0eu5JU0NdYj+GcC0MRadBpxZy0uSJEljNhXn5F8LvB4YzszHWokR8VHgMuANwO6UALrls8DrgE8Bh7WXq2VX7OXEEbEq5QbDAmCrzPxFTT8cmAe8MSL2zMz2YP/kzJzTpa6fAm+NiGMz87Je2iBpStiP3nvwO00H9gU+OXHNkSRJ0rJiyvXkZ+a8zDyzM1DPzFuA4+rLrVrpEfE84ADg58ChneVq2Ud6PP0bgdUpgfsv2so/CBxWX767o+4Hu7yPe4Af1pfP7/H8kia5uor+/n1Wc8DQrOGFpv9IkiRJizIVe/JH0wrWH21L24tyM+NEYNWI2JmyANYdwLzMvG4M9W9Tn89uOHYhcD+wWUSsnJkPjVZRRDyprb7/HUMbJE1u29F9kb1ezQC2B87qvzmSJElalkRmLu02TIiIWAH4FWVu/o6Z+cOaPpcyvP9Q4BCeOIQ2gS8BB2XmIvepjoifU+bwb5yZlzcc/w3wQuAFmXl1x7F1gbcCywPPBGYCzwE+lZkf7fE9LnTOaoMZM2Zw7LHHXtNLPUvYBvV5MrZNy57Ffj2ePT+ecdZNy6/Rbz07zVhw0w5r5G0T0SZNav5GajLxetRk4vWoyaTr9XjggQduMH/+/Gsy8+VLuE1dDVJP/mxKgP+DVoBfPaM+HwX8GPgQMAK8EjgeeA9wO3BkD+dYrT7f3eV4K/2pDcfWBY5oe/0w8C+U9QIkDYiHHmve4WOsHlwQy5X7kJIkSVLvBqInPyIOAj5PubPy6sy8s+3YZcArgJuA9TLzgbZjLwF+CdwHPD0zH17Eea6lzJ9/ftMw/4i4BNgU2DQzf9qljhUp+2K/hTKP/4fAGxZ17kW063KAyXT3qGXu3LmXA+yyyy6Trm1a9iyJ63Fo1vDBlN02+nXwyOyZn5+AejSJ+RupycTrUZOJ16Mmk9Gux8kYi025hfc6RcR7KQH+VcDW7QF+9df6fHZ7gA+QmVcCNwBPATbs4XStnvrVuhxftSPfQjLzkcz8Q2YeBXyMsur/QT2cW9LU8LsJqufaCapHkiRJy5ApHeRHxMHAF4HfUAL8Wxqytf7BfVeXalo3AVbp4ZStutZraMsKwNqURf+u76EueHxRra16zC9p8vsRML/POm4EzpmAtkiSJGkZM2WD/Ij4MGVI7BWUAL/bAlXn1ucXNdSxMo9vXzfSw2nn1ecdG45tATwJuGRRK+u3eW59fnTUXJKmjJHZMx+lrPfRj+NHZs9c5GKgkiRJUqcpGeRHxOGUhfYuB7bNzL+Mkv0sSs/6DhGxXcexwylD7y9oHwUQEatFxAYR8eyO/N8F/gLsGREbt+WfBhxdX36po62b13n4ne9h9foeAIZHab+kqefLlG06x+MO4IQJbIskSZKWIVNudf2I2JuyUv4C4CLgoIjozDaSmXMAMvPhWuYc4KyIOB34I2Uxvi0oK+vv11F+N+DrwInAPq3EzLwnIvalBPvnR8TJwJ2ULfrWr+mndNT1ReBZEXExZQjuAmAI2IkyReD7wNfG/klImqxGZs+8fWjW8M6U0T/TxlD0QWDnkdkzb188LZMkSdKgm3JBPmXeO5T95g/ukucCYE7rRWb+pPa8HwFsTdni7lZKb9u/ZeZNvZ48M78fEVsChwJvoPwD/jrgEOALufB2BZ8FdgVeCuwArEQZDTAP+CZwakMZSVPcyOyZlw7NGt4WOAOY3kOROygB/qWLt2WSJEkaZFMuyM/MI+ltT/vOclcBe/SYdw5tNwkajl9M6Ynvpa5vUoJ5ScuYkdkzLxmaNbwhsC9wADCjIduNwHHAV+zBlyRJUr+mXJAvSVNJDdw/OTRr+NPA9pTdOZ4C/I2yTd45LrInSZKkiWKQL0lLQA3kz+LxrTMlSZKkCTclV9eXJEmSJEkLM8iXJEmSJGlAGORLkiRJkjQgxhXkR8SCCXh8bKLfjCRJkiRJy7LxLrwXwB+BkXGW3WKc55UkSZIkSV30s7r+1zPzqPEUjIjH+jivJEmSJElq4Jx8SZIkSZIGxHh78lcH7u/jvP2WlyRJkiRJHcYV5GfmHf2ctN/ykiRJkiRpYQ7XlyRJkiRpQIw7yI+Ir0XE6zvS1utMazu2d0TMG+/5JEmSJEnS6Prpyd8H2KgjbS/g9C75h4At+zifJEmSJEkahcP1JUmSJEkaEAb5kiRJkiQNCIN8SZIkSZIGhEG+JEmSJEkDwiBfkiRJkqQBsUKf5TeKiLe3vwaIiLcB0Zm3z3NJkiRJkqRR9Bvk71If7QKY05A3gOzzfJIkSZIkqYt+gvwTJ6wVkiRJkiSpb+MO8jPzHRPZEEmSJEmS1J+luvBeRGwZER9bmm2QJEmSJGlQLO3V9bcCjljKbZAkSZIkaSAs7SBfkiRJkiRNEIN8SZIkSZIGhEG+JEmSJEkDwiBfkiRJkqQBYZAvSZIkSdKAMMiXJEmSJGlAGORLkiRJkjQgDPIlSZIkSRoQSzvIvxu4cSm3QZIkSZKkgbDEgvyIWCEi3tuelpmfy8y1l1QbJEmSJEkaZIs9yI9ib+Ba4AuL+3ySJEmSJC2rVuincEQ8DXgf8ArgEeAi4LjMfLAefx3wGWD9WuT0fs4nSZIkSZK6G3eQHxFPBy4D1gKiJu8KvD4itgOOA/65Hvsf4GOZeUV/zZUkSZIkSd3005M/CxgCrgS+RQnm3wZsCQwD2wM/A96fmZf110xJkiRJkrQo/QT5/wj8EdgkMx8GiIgvAtcA2wEnA2/JzOy7lZIkSZIkaZH6WXhvCPhBK8AHyMwHKEPzAQ43wJckSZIkacnpJ8hfBbi1If22+nx9H3VLkiRJkqQxWmxb6NmLL0mSJEnSktXXFnrARhHx9s40gIh4G4+vuv9/MvMbfZ5TkiRJkiQ16DfI36U+OgUwp0sZg3xJkiRJkhaDfoL8EyesFZIkSZIkqW/jDvIz8x0T2RBJkiRJktSfxbbwniRJkiRJWrIM8iVJkiRJGhDjCvIj4l8jYrPxnrTf8pIkSZIkaWHj7cmfDby2j/P2W16SJEmSJHXoZ3X9p0bEmhPWEkmSJEmS1Jd+gvz318d4ZB/nlSRJkiRJDcYb5J84Aee+YgLqkCRJkiRJ1biC/Mx8x0Q3RJIkLTuGZg2vAGwHrA88GbgX+B1wzsjsmQuWZtskSZrK+hmuL0mSNCZDs4ZXB/YD9gdmNGS5cWjW8PHACSOzZ96+RBsnSdIAGO/q+pIkSWMyNGt4M+Bq4GiaA3yANYFPAFcPzRredEm1TZKkQTHlgvyImB4R74qI0yPiuoh4ICLujoifRMQ7I6LxPUWxd0ScHxF31nI3RMSpEbHeGNuwWUT8oNZzf0T8OiIOjojlG/JuFBFHRsTFEfHniHg4Im6OiG9HxMvG+zlIkjSV1AD/XGB6j0WmA/MM9CVJGpspF+QDbwJOADYBfgZ8DjgNeBHwFeDUiIj2AhExDTgDmAM8CziplrsQ2BjoOciPiF1quS2A04H/BFYCjgFObihyHHAEsDLwvZrvN8CewM8iYrdezy1J0lRUh+ifAUwbY9FpwJm1vCRJ6sFUnJN/LfB6YDgzH2slRsRHgcuANwC7UwL/ls8CrwM+BRzWXq6WXbGXE0fEqpQbDAuArTLzFzX9cGAe8MaI2DMz24P9bwFvzczrOup6C/DfwAkRMZyZD/fSBkmSpqD96L0Hv9N0YF/gkxPXHEmSBteU68nPzHmZeWZnoJ6Zt1B6zQG2aqVHxPOAA4CfA4d2lqtlH+nx9G8EVgdObgX4tfyDwGH15bs76j62M8Cv6d8Cfk/5x8uLezy/JElTSl1Ff/8+qzlgaNbwQlPiJEnSwqZiT/5oWsH6o21pe1FuZpwIrBoRO1MW+7kDmNcUgI9im/p8dsOxC4H7gc0iYuXMfGic7ZUkaZBsR/dF9no1A9geOKv/5kiSNNgiM5d2GyZERKwA/IoyN3/HzPxhTZ9LGd5/KHAITxwumMCXgIMyc5F78kbEzylz+DfOzMsbjv8GeCHwgsy8ehF1bQL8FLgZWKvH8y90zmqDGTNmcOyxx16zqDqWgg3q82Rsm5Y9Xo+abAb+mjx7fjzjrJuWX6PfenaaseCmHdbI2yaiTepq4K9HTSlej5pMul6PBx544Abz58+/JjNfvoTb1NW4h+tHxPURcVBH2g4R8R9d8h8REYuzx3o2JcD/QSvAr55Rn48CfkEZGv8UYFvgD8B7gMN7PMdq9fnuLsdb6U8drZKIeBrwzfrykF4CfEmSpqKHHmve9WasHlwwMfVIkjToxt2THxGPAUdm5lFtaUcAH8vMpq3kuh7rV73Z8HnKnZVXZ+adbccuA14B3ASsl5kPtB17CfBL4D7g6Yta/C4irgWeDzy/aZh/RFwCbApsmpk/7VLH31GG+28OfCYzPzyW99qlzssBJtPdo5a5c+deDrDLLrtMurZp2eP1qMlmWbgmh2YNH0zZWaZfB4/Mnvn5CahHXSwL16OmDq9HTSajXY+TMRab8nfFI+K9lAD/KmDr9gC/+mt9Prs9wAfIzCuBGyg9+xv2cLpWT/1qXY6v2pGvs61/BwxTAvz/mIgAX5KkSe53E1TPtRNUjyRJA21KB/kRcTDwRcq+81vXFfY7tf5xcVeXalo3AVbp4ZStutZraMsKwNqURfSubzj+FMqCQVtSevA/2MP5JEma6n4EzO+zjhuBcyagLZIkDbwpG+RHxIcpw/+uoAT43RbjObc+v6ihjpUpw+8BRno47bz6vGPDsS2AJwGXdK6sHxGrUf5x8hrgE/bgS5KWFSOzZz4KHN9nNcePzJ7p+jWSJPVgSgb5EXE4ZaG9y4FtM/Mvo2Q/i9KzvkNEbNdx7HDK0PsL2kcBRMRqEbFBRDy7I/93gb8Ae0bExm35pwFH15df6mjr04AfA68CjsjMw3p8m5IkDYovU7auHY87gBMmsC2SJA20FZZ2A8YqIvamrJS/ALgIOCgiOrONZOYcgMx8uJY5BzgrIk4H/khZjG8L4HZgv47yuwFfB04E9mklZuY9EbEvJdg/PyJOBu6kbNG3fk0/paOu71G23fsDsFxEHNnwtr6fmVf09glIkjS1jMyeefvQrOGdKSPipo2h6IPAziOzZ96+eFomSdLg6TfI3zUihtpebwQQEV9ryPvSPs/VsnZ9Xh44uEueC4A5rReZ+ZPa834EsDVli7tbKT0L/5aZN/V68sz8fkRsCRwKvIHyj5XrgEOAL+TC2xW02vu8ev4mI5RpB5IkDaSR2TMvHZo1vC1wBjC9hyJ3UAL8SxdvyyRJGiz9Bvkb1UenfbrkH99+fe0VZB4JHDmOclcBe/SYdw5tNwkajl8M7NRjXUO95JMkadCNzJ55ydCs4Q2BfYEDgBkN2W4EjgO+Yg++JElj10+Q/44Ja4UkSVom1MD9k0Ozhj8NbE/ZseYpwN8o2+Sd4yJ7kiSN37iD/Mw8cSIbIkmSlh01kD+rPiRJ0gSZkqvrS5IkSZKkhS221fUj4iWURe4CuCgzf7G4ziVJkiRJkvroyY+ILSLiGxHxqoZjRwK/BD4L/Dvws4j4j3G3UpIkSZIkLVI/w/XfBLwZuLo9MSJeA3wMeAz4FmWF3DuA90dETyvSS5IkSZKksesnyN8U+Flm3t2Rvj9lq7yDMvPtmfleYAvgUVyRX5IkSZKkxaafIP85wO8b0rcB7gNOaCVk5jXAD4FX9HE+SZIkSZI0in6C/OnAre0JEfEs4FnAJZn5aEf+3wPP7ON8kiRJkiRpFP0E+Q+wcND+svr8q4b8D1GG7EuSJEmSpMWgnyD/GuAfI6J9G76ZlPn4lzTknwH8uY/zSZIkSZKkUfQT5H8XeDZwRkS8PiI+BLwTuBv4UUP+V9M8h1+SJEmSJE2AFRadpatjgb2AHYEdaloAH8rMB9szRsQmwFAtI0mSJEmSFoNxB/mZ+VBEbAF8gLKd3h3AKZk53JB9I2AucOZ4zydJkiRJkkbXT08+mXkfcHQP+Y4Hju/nXJIkSZIkaXT9zMmXJEmSJEmTSF89+U0iYk3K/PtO8zPzhok+nyRJkiRJKsYd5Net8y4G7gW2y8zH6qF3AB9rKHJ9RGyYmY+O95ySJEmSJKm7fnry3wi8AnhjW4DfEsC32l6vBswEdgO+08c5JUmSJElSF/0E+a8HbgFObziWmfm21ouICOBGYHcM8iVJkiRJWiz6WXjv5cAFmZmLyljznFfLSJIkSZKkxaCfIP85lN75Tnd3Sb8FeHYf55MkSZIkSaPoJ8hfEeici09mfi4z127Iv6CWkSRJkiRJi0E/Qf6dwIwx5F+zlpEkSZIkSYtBP0H+lcA2dSu9UdU8WwO/7uN8kiRJkiRpFP0E+cPAs4AP9pD3EOCZwJl9nE+SJEmSJI2inyD/a8DNwNERcVREPKUzQ0Q8OSI+DnwC+FMtI0mSJEmSFoNFDrXvJjPvj4g9gLOAQ4FDIuJySuCfwHOBjYFVgPuAN2XmA/03WZIkSZIkNRl3kA+QmZdExGbAF4Etgdc0ZDsfODAzf9vPuSRJkiRJ0uj6CvIBavC+dUSsA7yaMk8/gD8DF2fm9f2eQ5IkSZIkLVrfQX5LDebHFNBHxJbAlpl51ES1Q5IkSZKkZVU/C+9NhK2A/9/evcfLVZaHHv89ECCIXCSgtSa6uYXgrR6FWoJFQEFqwKCEA/YiXhGPQlPFYxQ4oqKmLXgDP0DxSPC0HkQohjQEqUZECCKgQC0EjLAlqaBAkIuQIOE5f6x3H4Zh9t6zb5mZtX/fz2d9Vmat9b7vM5OHCc+std71yQ7HIEmSJElSLXS6yJckSZIkSePEIl+SJEmSpJqwyJckSZIkqSYs8iVJkiRJqgmLfEmSJEmSasIiX5IkSZKkmrDIlyRJkiSpJkZd5EfEc8czEEmSJEmSNDZjOZN/c0TsPcbxHwLuHmMfkiRJkiSJsRX5LwauiohPR8Smo+kgM7+UmTuNIQZJkiRJklSMpcifDdwJnAisiIhdxyckSZIkSZI0GqMu8jPzeuBVwD8BewE/i4hjxiswSZIkSZI0MmOaXT8zH8/MDwCHAL8HzoqIxRGxe0S8uNUyLlFLkiRJkqRnmTIenWTmZRHxMuAbVAX/IYMdOl5jSpIkSZKkZxrPgvuVZQngXmD9OPYtSZIkSZKGMeYiPyI2Az4PzAeeBD4GnJaZOda+JUmSJElS+8ZU5JdL9P+F6gz+rcBfZebN4xGYJEmSJEkamVFPvBcRfwtcD7wCOAN4jQW+JEmSJEmdM5Yz+V8E7gHelZlXjFM8kiRJkiRplMbyCL1LgFdY4EuSJEmS1B1GfSY/Mw8fz0AkSZIkSdLYjOVMviRJkiRJ6iJjfoSeJEmSpLHpW7B0CnAgsDvwXOBR4Hbgiv6FczZ0MjZJvcUiX5IkSeqQvgVLdwSOAd4PzGhxyN19C5aeA5zbv3DOfRs1OEk9qecu14+IaRHx3oi4JCJWRcTjEfFQRFwdEe+JiJbvKSpHR8SVEbG2tLsrIi6MiJkjjGF2RFxW+nksIm6JiPkRsWmLY7eLiI9GxL9ExK0R8WREZES8cbSfgSRJknpf34Kls4HbgFNpXeADvBj4LHBb34Kle2+s2CT1rp4r8oEjgHOB1wLXAV8CLgZeDnwNuDAiorFBREwFLgUWAX8EfLO0uwrYE2i7yI+IuaXdvlRPGPgqsDnVIwUvaNGkD/gH4C+BrYH72x1LkiRJ9VQK/O8D09psMg1YbqEvaTi9WOTfAbwFmJ6Zf5WZH8/MdwOzgNXA4cDbmtqcDhwCfB54aWZ+qLQ7OvHU5YEAAB7jSURBVDN3Br7bzsARsQ3VDwwbgP0y8z2Z+VHgVcC1wLyIOKqp2a+ANwLTMnMGcPko3rMkSZJqolyifykwdYRNpwJLSntJaqnnivzMXJ6ZSzLzqabt9wJnl5f7DWyPiF2AY4HrgROb25W2f2hz+HnAjsAFmXlDQ/t1wEnl5Qea+n4wM7+fmWvbHEOSJEn1dgztn8FvNg143zjGIqlmeq7IH8ZAsf5kw7a3U73P84FtIuKvI+LjEXFMROw6wv4PKOtWZ+OvAh4DZkfEFiPsV5IkSZNAmUX//WPs5ti+BUufNReUJEGNZtePiCnAO8rLxiJ8r7LeFvglz/zVNCPiLOD4zGzn0SS7l/UdzTsy88mIuAt4GbAz1SQqkiRJUqMDGXySvXbNAA4Clo09HEl1E5nZ6RjGRUScBnwEuCwz5zRsvxb4M6r76L8HnAD0A38KnAPsCnwqM09pY4w7gN2A3TJzVYv91wCzgdmZee0gfSwCjgYOzMzvtf8OISJuHGTXrBkzZnDGGWesHEl/G8mssu7G2DT5mI/qNuakuon5uBFcvjqev2zNptPH2s+bZ2xY86bp+dvxiKlLmY/qJoPm43HHHTdr9erVKzPzNRs5pkHV4nL9iDieqsBfCfxN0+6BS5nuAd6amT/PzEczcznVPfZPAR+OiM3HI5SyrscvJ5IkSRpX659q/bjnkVq3YXz6kVQ/PX+5fkR8EPgycCvwhhYT3D1Y1pdn5uONOzLz5nKJ/S7AHsDNwwz3UFlvO8j+bZqOG1eD/ToUETeuXr2auXPnds2vRwMWL158I9CVsWnyMR/VbcxJdRPzceP42wVL51M9enlMlv96k3/4+vGHfnkcQupK5qO6yVD5eNhhhw12tXXH9PQvgBExHzgT+Dmwf5lhv9ntZf27QboZ+BFgyzaGHOhrZotYpgA7UU36d2cbfUmSJGnyuX34Q9ryrDmiJAl6uMiPiI9R/Qp6E1WBP9g9Sd8v65e36GMLqnvsobpPfzjLy/rgFvv2BZ4DrMjM9W30JUmSpMnn34HVY+zjbuCKcYhFUg31ZJEfEScDC4EbqS7Rv3+Iw5dRnVl/U0Qc2LTvZKpL73/YeBVARGwbEbMi4oVNx18E3A8cFRF7Nhw/FTi1vDxrNO9JkiRJ9de/cM6TVJM/j8U5/QvntPNkKEmTUM/dkx8RRwOfppot/0fA8RHRfFh/Zi4CyMwnSpsrgGURcQnwK6pH6+0L3Acc09T+rcB5wPnAOwc2ZubDEfE+qmL/yoi4AFgLvIXq8XoXAd9qEfNpwA7l5evK+qMR8dflz9/JzO+0/ylIkiSph/0T8Hc889HO7XoAOHd8w5FUJz1X5FPd9w7VrPnzBznmh8CigReZeXU58/5JYH9gO+A3VF+wn8nMNe0OnpnfiYjXAycChwNTgVXAh4GvZOtnEs4DXtK07aCGP/cDFvmSJEmTQP/COff1LVh6KNWtoFNH0HQdcGj/wjn3TUxkkuqg54r88jz7U0bR7lbgyDaPXUTDjwQt9l8DvHkEY/e1e6wkSZLqr3/hnGv7Fix9A3Ap7Z3Rf4CqwL92YiOT1Ot68p58SZIkqdf1L5yzguoxzicy+GR8dwOfAPawwJfUjp47ky9JkiTVRbn0/nN9C5b+PdXtnDOBrYFHqB6Td4WT7EkaCYt8SZIkqcNKIb+sLJI0al6uL0mSJElSTVjkS5IkSZJUExb5kiRJkiTVhEW+JEmSJEk1YZEvSZIkSVJNWORLkiRJklQTFvmSJEmSJNWERb4kSZIkSTVhkS9JkiRJUk1Y5EuSJEmSVBMW+ZIkSZIk1YRFviRJkiRJNWGRL0mSJElSTVjkS5IkSZJUExb5kiRJkiTVhEW+JEmSJEk1YZEvSZIkSVJNWORLkiRJklQTFvmSJEmSJNWERb4kSZIkSTVhkS9JkiRJUk1Y5EuSJEmSVBMW+ZIkSZIk1YRFviRJkiRJNWGRL0mSJElSTVjkS5IkSZJUExb5kiRJkiTVhEW+JEmSJEk1YZEvSZIkSVJNWORLkiRJklQTFvmSJEmSJNWERb4kSZIkSTVhkS9JkiRJUk1Y5EuSJEmSVBMW+ZIkSZIk1YRFviRJkiRJNWGRL0mSJElSTVjkS5IkSZJUExb5kiRJkiTVhEW+JEmSJEk1YZEvSZIkSVJNWORLkiRJklQTFvmSJEmSJNWERb4kSZIkSTVhkS9JkiRJUk1Y5EuSJEmSVBMW+ZIkSZIk1YRFviRJkiRJNWGRL0mSJElSTVjkS5IkSZJUExb5kiRJkiTVxJROByBJkiRJUqO+BUunAAcCuwPPBR4Fbgeu6F84Z0MnY+t2FvmSJEmSpK7Qt2DpjsAxwPuBGS0OubtvwdJzgHP7F865b6MG1yO8XF+SJEmS1HF9C5bOBm4DTqV1gQ/wYuCzwG19C5buvbFi6yU9V+RHxLSIeG9EXBIRqyLi8Yh4KCKujoj3RETL9xSVoyPiyohYW9rdFREXRsTMEcYwOyIuK/08FhG3RMT8iNh0iDaHlLEfiohHI+K6iDh6pO9fkiRJkuqmFPjfB6a12WQasNxC/9l6rsgHjgDOBV4LXAd8CbgYeDnwNeDCiIjGBhExFbgUWAT8EfDN0u4qYE+g7SI/IuaWdvsClwBfBTYHvghcMEibDwFLSoz/XOL/Y2BRRJzW7tiSJEmSVDflEv1LgakjbDoVWFLaq+jFe/LvAN4CLM3MpwY2RsQngJ8AhwNvoyr8B5wOHAJ8HjipsV1pu1k7A0fENlQF+gZgv8y8oWw/GVgOzIuIozLzgoY2fcBpwFpgz8zsL9s/DVwPfCQiLs7Ma9t8/5IkSZJUJ8fQ/hn8ZtOA9wGfG79welvPncnPzOWZuaS5UM/Me4Gzy8v9BrZHxC7AsVQF9YnN7UrbP7Q5/DxgR+CCgQK/tF8HnFRefqCpzbuBLYAzBwr80uZBnk7EY9scX5IkSZJqo8yi//4xdnNs34Klg946Pdn04pn8oQwU6082bHs71Y8Z5wPbRMShVJM4PAAsz8xVI+j/gLK+vMW+q4DHgNkRsUVmrm+jzbKmYyRJkiRpMjmQwSfZa9cM4CCerq8mtcjMTscwLiJiCvAzqvveD87M75bti6ku7z8R+DDPvAwkgbOA4zNz2GctRsT1VPfw75mZN7bY/3PgZcBLM/O2su0+YAdgh8x8oEWbR4GtgK0y87Fhxn/WmMWsGTNmcMYZZ6wc7j10wKyy7sbYNPmYj+o25qS6ifmobmI+ThKXr47nL1uz6fSx9vPmGRvWvGl6/nY8Ymph0Hw87rjjZq1evXplZr5mgsYesZ67XH8IC6kK/MsGCvzi+WX9aeAG4BXA1sAbgF8C/wM4uc0xti3rhwbZP7B9u1G02XaQ/ZIkSZJUS+ufav10tJFat2F8+qmDWpzJj4jjgS9T/bKyT2aubdj3E2AvYA0wMzMfb9j3J8BPgd9TnWl/Yphx7gB2A3ZrdZl/RKwA9gb2zswfl21PAJsBm2Xmky3a/Bp4IfDCMq/AiA2c4e+mX48GLF68+EaAuXPndl1smnzMR3Ubc1LdxHxUNzEfJ4++BUvnUz2pbKzm9y+c8+Vx6OdZhsrHbqzFev7Xjoj4IFWBfyuwf2OBXzxY1pc3FvgAmXkzcBfVmf092hhuuLPu2zQdN5I2D7cxviRJkiTVye3j1M8d49RPz+vpIj8i5gNnAj+nKvBbnQkfSJrfDdLNwI8AW7Yx5EBfM1vEMgXYiWrSvzvbbPNCqvvx1wx3P74kSZIk1dC/A6vH2MfdwBXjEEst9GyRHxEfo7qs4yaqAn+wSRa+X9Yvb9HHFlSX3wP0tzHs8rI+uMW+fYHnACsaZtYfrs1fNB0jSZIkSZNG/8I5TwLnjLGbc/oXzhl2IvXJoieL/Ig4mWqivRuBN2Tm/UMcvozqzPqbIuLApn0nU11G/8PGqwAiYtuImFXOtDe6CLgfOCoi9mw4fipwanl5VlOb84D1wIcioq+hzfOAT5SXZw8RvyRJkiTV2T9RPeJ8NB4Azh3HWHrelE4HMFIRcTTVTPkbgB8Bx0dE82H9mbkIIDOfKG2uAJZFxCXAr6gm49sXuA84pqn9W6mK8/OBdw5szMyHI+J9VMX+lRFxAbCW6hF9u5ft32rsKDPvioiPAl8BboiIbwFPAPOA6cDpmXntaD8PSZIkSepl/Qvn3Ne3YOmhVFc4Tx1B03XAof0L59w3MZH1pp4r8qnuewfYFJg/yDE/BBYNvMjMq8uZ908C+1M94u43VL8YfSYz17Q7eGZ+JyJeD5wIHE6VhKuADwNfyRaPK8jMMyKiHzgBeAfVFRS3Aidl5vntji1JkiRJddS/cM61fQuWvgG4FJjWRpMHqAp8T5g26bkiPzNPAU4ZRbtbgSPbPHYRDT8StNh/DfDmEY6/BFgykjaSJEmSNFn0L5yzom/B0j2A9wHHAjNaHHY31e3OX/MMfms9V+RLkiRJkuqpFO6f61uw9O+Bg6ieUrY18AjVY/KucJK9oVnkS5IkSZK6Sinkl5VFI9CTs+tLkiRJkqRns8iXJEmSJKkmLPIlSZIkSaqJaPHEN/WYiHiA6lF+KzsdS7MZM2bMAli9enXXxabJx3xUtzEn1U3MR3UT81HdZJh8nAWsy8x2Hvu3UTjxXj08PMj2TYAXAL8Bntp44Txt9erVQZVnm3QqBrrgczCG7ojBfDSGbovBnOyK8Y2hMB+7JoZOj98VMZiPxtBF4w+Xj+sYvB7rCM/k11hE/DHwX8CLMvPXHYrhFuAVHY6hGz4HY+iCGMxHY+jCGCZ9TnZ6fGN4RgyTPh+7IYZOj99FMZiPxtAV45cYOp6PI+E9+ZIkSZIk1YRFviRJkiRJNWGRX2+PAJ8q607ZANzT4Ri64XMwhu6IwXw0hm6LwZzs/PjG8DTzsTti6PT43RKD+WgM3TI+dEc+ts178jWhIuJGgMx8TadjkcxHdRtzUt3EfFQ3MR/VTXotHz2TL0mSJElSTXgmX5IkSZKkmvBMviRJkiRJNWGRL0mSJElSTVjkS5IkSZJUExb5kiRJkiTVhEW+JEmSJEk1YZEvSZIkSVJNWORLkiRJklQTFvmTXERMj4ivR8SvI2J9RPRHxJci4nktjs0hlh+PYuxNI2J+RNwSEY9HxNqIuCwiZg/RZsuI+FRE3B4R6yLitxFxYUTsMdLx1X06lY8RsUfJq8URcXdDP1OGabd9ia+/xPvrEv/0kb53dZ9O5GNUDo6IMyLipoh4sHzX3V7GfsEQbc3HGuvg9+NhEfGtiFhZ8vHxiPhFRPzfiNhziHbmY4118v8fm/reISLuLX1dPR7xqjd18DvylGH6O3iQdhP6HRmZOR79qAdFxC7ACuD5wGJgJfCnwP7A7cA+mflAw/EJ/ApY1KK7NZn5tRGMHcCFwLwy1hJge+BIYCpweGYubmqzBfB9YB/gBmA5MAM4AngCOCAzr2s3BnWXDufjfOCLwAbgF0AfVR5ulplPDtJmWol3JlUuXg/MAuYCvwX2zsw7241B3aVT+RgRU4HHqb7TrgJuBjYFDgBeCfwG+PPM/EVTO/Oxxjr8/Xge8HqqnPo1VW7uCswBNgeOae7PfKy3TuZji1guBg4Cngtck5mvG2u86j0d/o48BfgkcD7Q3+KQf87MVU1tJv47MjNdJukCfBdI4Lim7V8o289u2p7AleM09ttLf9cAUxu27wWsLwm+dVObj5c23wY2adg+t2z/z8btLr21dDgfdwdeC2xZXveX/qcM0eaccswXmrYfX7Zf3unP1GVMOdGRfAQ2A04Ente0fRPg7DLOkhbtzMcaLx3+fpw6yPZXAOuA3wGbN+0zH2u8dDIfm/p9R+n7A2V99XjE69J7S4e/I08p/e03gjYT/h3Z8b8Ul84swM4lie6iqTAGtgYeBX4PbNWwfTz/g7iq9Ld/i33fKPve1bAtqH5xS2CnkfTn0v1Lp/OxRTz9DFHkA1sBj5W4mn+M2qS8jwR27vRn6zKqv/+uyseGMf64jPNI03bzscZLt+ZjGednZawXNWwzH2u8dEs+Ai+m+oHpa1RX37Us8kcTr0tvLZ3OSUZY5G+s70jvyZ+8DijrKzLzqcYdmfkI1Rn25wB/1tRuu4h4d0R8IiI+GBHN+59h4H6Upm1bALOpEvxHLZota4oRYBeqL/Q7MvOuNtuod3QsH0dpb2BLqksDH2mK9yngivJy/3EYSxtft+bjE2XdfAuJ+VhvXZmPETGT6iqo+4F7GnaZj/XW8Xwst3wuAh4CPjxB8ap3dDwni9dFxEci4mMRcWRE7DDIcRvlO3LISaVUa7uX9R2D7P8F1T1OM6nugx/wJ8D/bjwwIm4G/iYz/6PNsXelusf0zmx9v/PAvaYzRxhvcxv1jk7m42iYj/XWrfn4nrK+vGm7+VhvXZGPEfFG4HVU9+HvBBxadr236X+szcd664Z8nA/sBxyUmQ9HxPYTEK96RzfkJMBnml6vj4h/BP5XltP0I4gXxvgd6Zn8yWvbsn5okP0D27dr2PYFqknvdqS6/GUv4CKq/0iWR8SLWvSzR1nGOvZo2qh3dDIfR8N8rLeuy8eI2ItqYp9HgJPGIV71jm7JxzdS5eDHgaOocvGt2TRJ7ijjVe/oaD5GxEuBz1HdY/29CYpXvaXT35E3A++mum1gS+AlwPuobic5CfjsOMQ7Yhb5GkyU9f//5SkzP5KZKzLz/sx8NDNvyMwjgIuBHYATmjvJzJWZuXKsY09QG/WOTubjuMSrWtmo+Vgui15CNSnfX2fmL8car2plo+RjZi7IzKCaxfzVVDNCL4uIE8car2plwvIxIjYD/g/V7SH/c6LiVe1M6HdkZl6Smedl5l2ZuS4z785qdv43A38AThji0v224h0Ni/zJa+BXom0H2b9N03FDObus953AscczXnWfTubjaJiP9dY1+RgRuwE/oHrE6FGZeWmLw8zHeuuafATIzN9n5s8y86+oZrT+TLnSZID5WG+dzMePA/+NamLmR9tsYz7WX1d9Rw7IzJ8CP6H6gX7vhl0bJSct8iev28t6sPs9divrwe4XaXRfWW/V5tirqJ5HvnNEtJoXotXY4xmvuk8n83E0zMd664p8jIg9gB9SnVU4IjMvHuRQ87HeuiIfB3E51Vmn1zdsMx/rrZP5+GqqfLtyYBK0MhHawITM+5Rtv5ugeNWduvk7slV/GyUnnXhv8vpBWR8UEZs0TpoTEVtT3afyOPDjNvoamI3yznYGzsz1EbEC+POy/KDpkL8o6+UN234J3A3MjIidWsyw36qNekfH8nGUfkwVzz4RsXXj7KgRsQnVBC/w7NxWb+h4PkbEK4DvUf3Sf3hm/tsQh5uP9dbxfBzCwH2rjZPomo/11sl8/Heqpzk0ey5wJPAb4N+ont40EfGqO3Xld2S5veTVLfrbON+RI33mnkt9FqrL7BI4rmn7F8r2sxu2vZoWzxAFXkn1hZvAX7bYPwuY1WL720uba4CpDdv3AtYDvwW2aWrz8dLm2zQ8BxOYW7b/J03Px3TpnaWT+djiuP7Sx5QhjjmnHHN60/bjy/bLO/2Zuox+6fD346tKu8eAN7UZr/lY46VT+QhsAcweJKa9gIeprsxrbmc+1njppn+vy7F9pZ+rxxqvS28uHfyO3Bp4VYtjNwe+Wvq6jab6ZGN8R0bpUJNQROwCrACeDyymSsLXUj2X8Q6qf9gfKMcuAt5GdaZ8NVUhPgs4mOpxeOcC78+mhBp4nmRWk/U0bg/gQmAesJJqUqlpVL/ETqU6c7W4qc0WZfzZwA1Uj8F4MXAE1fOjD8jM68b2qahTOpyPOwCnNWyaR3Vp1Td4euKThdkw4UpETCvxzixx/IRq1tW5VD9Szc6RT5CmLtGpfIyI51Hd0rQ91Xfc1YOE+KXM/F1DO/OxxjqYj9sBD1L9O/1TYA3V86b34OlnU380M09v6st8rLFO/ns9SDx9VJfsX5OZrxtLvOpNHfyO7KPKvZuAW6gmhdyxjLsT1Y8GB2bmTU19Tfx3ZKd/eXHp7ALMAM4rSfkE8Cvgy8D2TccdBvwr1f98PlyOvYeqOH/LEP1nlWYt900B/g74D6rLVh4ELmOQswalzZbAp6ieIbme6l6XbwMv7fRn6dK7+cjTZwGGWvZr0W77Et+vGmL4OjC905+lS2/mY5u5mEBfi/7MxxovHcrHzYCTqW4dWQOsK/9er6L6EfS1Q/RnPtZ46dS/14McO/C92fJM/kjidendpUPfkdsAX6G6BP/e0tejVI/VWwg8f4j+JvQ70jP5kiRJkiTVhLPrS5IkSZJUExb5kiRJkiTVhEW+JEmSJEk1YZEvSZIkSVJNWORLkiRJklQTFvmSJEmSJNWERb4kSZIkSTVhkd9hETEtIt4bEZdExKqIeDwiHoqIqyPiPRHR8u8oImZHxGURsTYiHouIWyJifkRsOsRYh0TElaX/RyPiuog4epBjp0fEiRHx7RLXUxGREbHrGN/v0RHxkzL+QyWeQwY5do+I+FRELI6Iu8v4GRFTxjD+puVzuqV81mvL5zh7kOP/NCI+HxHLIuLeMv6a0Y4vSZIkSRMpMrPTMUxqEXEscBZwD/AD4G7gBcDbgG2Bi4EjsuEvKiLmlu3rgG8Ba4FDgd2BizLziBbjfAg4A3igtHkCmAdMB07PzBOajj8MuARI4C5ge2A7YLfMXDXK93oa8BFgDXARsDlwVOn7uMw8s+n4+cAXgQ3AL4A+YCqwWWY+OYrxA7iQ6n3fDiwpYx9Z+j08Mxc3tfkS8LfAH4DbgFcC/5WZ00c6viRJkiRNNIv8DouIA4CtgKWZ+VTD9j8CfgLMAOZl5sVl+zbAKqofAPbJzBvK9qnAcmBv4O2ZeUFDX33ASuD3wGsys79sfx5wPbALMDszr21oMx3YCbg5Mx+OiCuB1zPKIr+cKb8G+CWwV2Y+2BDbjeUzmDUQW9m3O9UPC7dk5uMR0Q+8hNEX+W8HvgmsAN6QmevK9r2Aq4GHgF0y85GGNq8CAvjPzHwiIhKLfEmSJEldysv1Oywzl2fmksYCv2y/Fzi7vNyvYdc8YEfggoECvxy/DjipvPxA0zDvBrYAzmwsokuh/bny8tim8ddk5o8y8+HRvK8WBvr/7ECBX8bpB75a4ntXUwy3Z+Z1mfn4OMUw8LmcNFDgl3Gup7q6YUeqz7cxhpsy82eZ+cQ4xSBJkiRJE8Yiv7v9oawbz1ofUNaXtzj+KuAxYHZEbNFmm2VNx0yUjsZQPo/ZVJ/PjzoRgyRJkiRNNIv8LlUml3tHedlYGO9e1nc0tymXsN8FTAF2brPNPVSX8U+PiOeMMeyWImIr4EXAo2W8Zr8o65kTMX6xK7ApcOcgl/pvjBgkSZIkaUJZ5HevhcDLgcsy87sN27ct64cGaTewfbtRtNl2kP1jNZqY6xiDJEmSJE2oUT+KTBMnIo6nmoV+JfA3I21e1iOZUXE0bZ7ZQcQ7qWa/b3RlZl45gm7GNAtkmY2/uUj/Tmbe1E7z8YhBkiRJkjrJIr/LRMQHgS8Dt1LNAL+26ZDhzrpv03TcwJ93KG0eGKLNWCbZeyfV7PvNrmT4mIc7y96u+VSz7zfqB25qI4ZWn5skSZIk9RSL/C7S8Fz4n1MV+L9tcdjtwJ5U947f2NR+CtVj754E7mxqs0Npc21TmxdSPb5uTWY+NtrYM3O/Ifb9PiL+C3hRRLywxX35u5X1s+YMGGEMfUPsXgVsAHaOiCkt7ssflxgkSZIkqZO8J79LRMTHqAr8m4D9BynwAZaX9cEt9u0LPAdYkZnr22zzF03HTJSOxlA+jxVUn8+fdyIGSZIkSZpoFvldICJOpppo70aqM/j3D3H4RcD9wFERsWdDH1OBU8vLs5ranAesBz4UEX0NbZ4HfKK8PHsMb6EdA/2fWMYdiKEP+GCJ77wJjmHgczm1fF4DMewFHAncB1w8wTFIkiRJ0oSJTOcZ66SIOBpYRHUp+Rm0vie8PzMXNbQ5jKrYXwdcAKwF3kL1qLyLgP+eTX+xEXEc8BWqe/K/BTwBzAOmA6dn5gktYlvU8PJg4AXAvwKPlG1fy8yrR/BeTwc+DKwpcW5OVVxPA47LzDObjt8BOK1h0zyqWwu+wdMT5C3MzJVtjh/AhaWflcCSMvaRwFTg8Mxc3NRmFrCgYdPRwGPAtxu2nTDMDzOSJEmStFFY5HdYRJwCfHKYw37YfM97ROwDnAjsTVWgrgK+DnwlMzcMMtahwAnAq6mu4rgVODMzzx/k+OGS412NPz60o/yo8SHgpcBTwE+Bf8zMf2txbB9w1zBd7j+SGfzLvAXHAe8GdqX6oeRa4NTMXNHi+P2AHwzT7U6Z2d9uDJIkSZI0USzyJUmSJEmqCe/JlyRJkiSpJizyJUmSJEmqCYt8SZIkSZJqwiJfkiRJkqSasMiXJEmSJKkmLPIlSZIkSaoJi3xJkiRJkmrCIl+SJEmSpJqwyJckSZIkqSYs8iVJkiRJqgmLfEmSJEmSasIiX5IkSZKkmrDIlyRJkiSpJizyJUmSJEmqCYt8SZIkSZJqwiJfkiRJkqSasMiXJEmSJKkm/h+H0W/mhTdSgQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'startDate': '1997-08-25T17:48:00.000Z',\n", + " 'stopDate': '2019-02-04T23:36:00.000Z',\n", + " 'cadence': 'PT720S',\n", + " 'description': 'Ephemeris data',\n", + " 'resourceURL': 'https://sscweb.sci.gsfc.nasa.gov/',\n", + " 'parameters': [{'name': 'Time',\n", + " 'type': 'isotime',\n", + " 'units': 'UTC',\n", + " 'fill': None,\n", + " 'length': 18},\n", + " {'name': 'X_GSE',\n", + " 'description': 'X Position in the Geocentric Solar Ecliptic coordinate system',\n", + " 'units': 'R_E',\n", + " 'fill': '1e31',\n", + " 'type': 'double',\n", + " 'hapiplot': {'figure':
}},\n", + " {'name': 'Y_GSE',\n", + " 'description': 'Y Position in the Geocentric Solar Ecliptic coordinate system',\n", + " 'units': 'R_E',\n", + " 'fill': '1e31',\n", + " 'type': 'double',\n", + " 'hapiplot': {'figure':
}},\n", + " {'name': 'Z_GSE',\n", + " 'description': 'Z Position in the Geocentric Solar Ecliptic coordinate system',\n", + " 'units': 'R_E',\n", + " 'fill': '1e31',\n", + " 'type': 'double',\n", + " 'hapiplot': {'figure':
}}],\n", + " 'HAPI': '2.0',\n", + " 'status': {'code': 1200, 'message': 'OK'},\n", + " 'x_server': 'http://hapi-server.org/servers/SSCWeb/hapi',\n", + " 'x_dataset': 'ace',\n", + " 'x_parameters': 'X_GSE,Y_GSE,Z_GSE',\n", + " 'x_time.min': '2001-01-01T05:00:00',\n", + " 'x_time.max': '2001-01-01T06:00:00',\n", + " 'x_requestDate': '2019-05-21T10:41:02',\n", + " 'x_cacheDir': '/tmp/hapi-data/hapi-server.org_servers_SSCWeb_hapi',\n", + " 'x_downloadTime': 0.7665941715240479,\n", + " 'x_readTime': 0.00021696090698242188,\n", + " 'x_metaFileParsed': '/tmp/hapi-data/hapi-server.org_servers_SSCWeb_hapi/ace.pkl',\n", + " 'x_dataFileParsed': '/tmp/hapi-data/hapi-server.org_servers_SSCWeb_hapi/ace_X_GSE-Y_GSE-Z_GSE_20010101T050000_20010101T060000.npy',\n", + " 'x_metaFile': '/tmp/hapi-data/hapi-server.org_servers_SSCWeb_hapi/ace.json',\n", + " 'x_dataFile': '/tmp/hapi-data/hapi-server.org_servers_SSCWeb_hapi/ace_X_GSE-Y_GSE-Z_GSE_20010101T050000_20010101T060000.bin'}" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-cTz3pY0W6Dj" + }, + "source": [ + "## CDAWeb data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PsxllYbuW6Dj", + "outputId": "716f55d1-e256-44fe-c923-2b760538b4b1" + }, + "source": [ + "from hapiclient import hapi\n", + "from hapiclient import hapiplot\n", + "\n", + "server = 'https://cdaweb.gsfc.nasa.gov/hapi'\n", + "dataset = 'AC_H0_MFI'\n", + "start = '2001-01-01T05:00:00'\n", + "stop = '2001-01-01T06:00:00'\n", + "parameters = 'Magnitude,BGSEc'\n", + "opts = {'logging': True, 'usecache': True}\n", + "\n", + "# Get data\n", + "data, meta = hapi(server, dataset, parameters, start, stop, **opts)\n", + "\n", + "# Plot all parameters. See section 3 and 4 for information\n", + "# on extracting data and using other plotting functions.\n", + "hapiplot(data, meta)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "hapi(): Running hapi.py version 0.0.9b0\n", + "hapi(): hapi(): file directory = cdaweb.gsfc.nasa.gov_hapi\n", + "hapi(): Reading https://cdaweb.gsfc.nasa.gov/hapi/info?id=AC_H0_MFI\n", + "hapi(): Writing AC_H0_MFI.json \n", + "hapi(): Writing AC_H0_MFI.pkl \n", + "hapi(): Reading https://cdaweb.gsfc.nasa.gov/hapi/capabilities\n", + "hapi(): Writing https://cdaweb.gsfc.nasa.gov/hapi/data?id=AC_H0_MFI¶meters=Magnitude,BGSEc&time.min=2001-01-01T05:00:00&time.max=2001-01-01T06:00:00&format=binary to AC_H0_MFI_Magnitude-BGSEc_20010101T050000_20010101T060000.bin\n", + "hapi(): Reading AC_H0_MFI_Magnitude-BGSEc_20010101T050000_20010101T060000.bin\n", + "hapi(): Writing cdaweb.gsfc.nasa.gov_hapi/AC_H0_MFI_Magnitude-BGSEc_20010101T050000_20010101T060000.pkl\n", + "hapi(): Writing cdaweb.gsfc.nasa.gov_hapi/AC_H0_MFI_Magnitude-BGSEc_20010101T050000_20010101T060000.npy\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'HAPI': '2.0',\n", + " 'status': {'code': 1200, 'message': 'OK'},\n", + " 'parameters': [{'name': 'Time',\n", + " 'type': 'isotime',\n", + " 'units': 'UTC',\n", + " 'length': 24,\n", + " 'fill': None},\n", + " {'name': 'Magnitude',\n", + " 'type': 'double',\n", + " 'units': 'nT',\n", + " 'fill': '-1.0E31',\n", + " 'description': 'B-field magnitude',\n", + " 'hapiplot': {'figure':
}},\n", + " {'name': 'BGSEc',\n", + " 'type': 'double',\n", + " 'units': 'nT',\n", + " 'fill': '-1.0E31',\n", + " 'description': 'Magnetic Field Vector in GSE Cartesian coordinates (16 sec)',\n", + " 'size': [3],\n", + " 'hapiplot': {'figure':
}}],\n", + " 'startDate': '1997-09-02T00:00:12Z',\n", + " 'stopDate': '2019-02-15T23:59:50Z',\n", + " 'resourceURL': 'https://cdaweb.sci.gsfc.nasa.gov/misc/Notes.html#AC_H0_MFI',\n", + " 'contact': 'voycrs@gmail.com',\n", + " 'x_server': 'https://cdaweb.gsfc.nasa.gov/hapi',\n", + " 'x_dataset': 'AC_H0_MFI',\n", + " 'x_parameters': 'Magnitude,BGSEc',\n", + " 'x_time.min': '2001-01-01T05:00:00',\n", + " 'x_time.max': '2001-01-01T06:00:00',\n", + " 'x_requestDate': '2019-05-15T22:39:30',\n", + " 'x_cacheDir': '/var/folders/_p/1v6cbz012xvfz3m77y5_kvz80000gn/T/hapi-data/cdaweb.gsfc.nasa.gov_hapi',\n", + " 'x_downloadTime': 0.25660085678100586,\n", + " 'x_readTime': 0.0004520416259765625,\n", + " 'x_metaFileParsed': '/var/folders/_p/1v6cbz012xvfz3m77y5_kvz80000gn/T/hapi-data/cdaweb.gsfc.nasa.gov_hapi/AC_H0_MFI.pkl',\n", + " 'x_dataFileParsed': '/var/folders/_p/1v6cbz012xvfz3m77y5_kvz80000gn/T/hapi-data/cdaweb.gsfc.nasa.gov_hapi/AC_H0_MFI_Magnitude-BGSEc_20010101T050000_20010101T060000.npy',\n", + " 'x_metaFile': '/var/folders/_p/1v6cbz012xvfz3m77y5_kvz80000gn/T/hapi-data/cdaweb.gsfc.nasa.gov_hapi/AC_H0_MFI.json',\n", + " 'x_dataFile': '/var/folders/_p/1v6cbz012xvfz3m77y5_kvz80000gn/T/hapi-data/cdaweb.gsfc.nasa.gov_hapi/AC_H0_MFI_Magnitude-BGSEc_20010101T050000_20010101T060000.bin'}" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7Mm5y0eVW6Dk" + }, + "source": [ + "## CASSINI" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "A77KQu--W6Dk", + "outputId": "7cb876c7-f97e-4418-c2dc-435fca463e69" + }, + "source": [ + "from hapiclient import hapi\n", + "from hapiclient import hapiplot\n", + "\n", + "server = 'http://datashop.elasticbeanstalk.com/hapi';\n", + "dataset = 'CHEMS_PHA_BOX_FLUXES_FULL_TIME_RES';\n", + "parameters = 'HPlus_BEST_T1';\n", + "start = '2004-07-01T04:00:00Z';\n", + "stop = '2004-07-01T06:00:00Z';\n", + "opts = {'usecache': True}\n", + "\n", + "# Get parameter data. See section 5 for for information on getting available datasets and parameters\n", + "data,meta = hapi(server, dataset, parameters, start, stop, **opts)\n", + "\n", + "# Plot all parameters. See section 3 and 4 for information\n", + "# on extracting data and using other plotting functions.\n", + "popts = {'logging': False, 'logy': True, 'logz': True}\n", + "hapiplot(data, meta, **popts)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\u001b[31mheatmap() warning: \u001b[0mOnly bin centers given for x and bin separation distance is not constant. Bin width assumed based on separation distance and data pickers will not work properly.\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'HAPI': '2.0',\n", + " 'status': {'code': 1200, 'message': 'OK'},\n", + " 'parameters': [{'name': 'Epoch',\n", + " 'type': 'isotime',\n", + " 'length': 22,\n", + " 'units': 'UTC',\n", + " 'fill': None,\n", + " 'description': 'time as UTC string to milliseconds'},\n", + " {'name': 'HPlus_BEST_T1',\n", + " 'type': 'double',\n", + " 'units': 'particles/s/keV/cm^2/ster',\n", + " 'size': [32],\n", + " 'fill': '-1.0e38',\n", + " 'description': 'HPlus_BEST_T1',\n", + " 'bins': [{'name': 'energy',\n", + " 'units': 'keV',\n", + " 'centers': [2.809683857215968,\n", + " 3.289629854178126,\n", + " 3.7795747260769956,\n", + " 4.399504972153117,\n", + " 5.049431843039373,\n", + " 5.859340712913015,\n", + " 6.74924058228035,\n", + " 7.809121325571782,\n", + " 8.918996443546773,\n", + " 10.298841184812979,\n", + " 11.798672425319724,\n", + " 13.598469913927815,\n", + " 15.698233650637256,\n", + " 18.09796363544805,\n", + " 20.79765986836019,\n", + " 23.897311098740794,\n", + " 27.39691732658986,\n", + " 31.496456050641633,\n", + " 36.1959272708961,\n", + " 41.59531973672038,\n", + " 47.79462219748159,\n", + " 54.89382340254684,\n", + " 63.1928896000175,\n", + " 72.59183204052643,\n", + " 83.390616972175,\n", + " 95.88921064306453,\n", + " 110.08761305319503,\n", + " 126.58575669876923,\n", + " 145.28365283041998,\n", + " 166.8812226937171,\n", + " 191.57844378739483,\n", + " 220.17522610639006],\n", + " 'ranges': [[2.76785, 2.85215],\n", + " [3.24065, 3.3393499999999996],\n", + " [3.7232999999999996, 3.8366999999999996],\n", + " [4.3340000000000005, 4.466],\n", + " [4.97425, 5.125749999999999],\n", + " [5.7721, 5.9479],\n", + " [6.64875, 6.851249999999999],\n", + " [7.692849999999999, 7.927149999999999],\n", + " [8.7862, 9.053799999999999],\n", + " [10.1455, 10.4545],\n", + " [11.623000000000001, 11.977],\n", + " [13.395999999999999, 13.803999999999998],\n", + " [15.4645, 15.935499999999998],\n", + " [17.828500000000002, 18.3715],\n", + " [20.488, 21.112],\n", + " [23.5415, 24.258499999999998],\n", + " [26.988999999999997, 27.810999999999996],\n", + " [31.0275, 31.972499999999997],\n", + " [35.657000000000004, 36.743],\n", + " [40.976, 42.224],\n", + " [47.083, 48.516999999999996],\n", + " [54.076499999999996, 55.723499999999994],\n", + " [62.252, 64.148],\n", + " [71.511, 73.689],\n", + " [82.149, 84.651],\n", + " [94.4615, 97.3385],\n", + " [108.4485, 111.75149999999998],\n", + " [124.701, 128.499],\n", + " [143.12050000000002, 147.4795],\n", + " [164.3965, 169.40349999999998],\n", + " [188.726, 194.474],\n", + " [216.897, 223.50299999999996]]}],\n", + " 'hapiplot': {'figure':
,\n", + " 'colorbar': }}],\n", + " 'startDate': '2004-001T00:00:04.734Z',\n", + " 'stopDate': '2017-258T10:31:10.425Z',\n", + " 'sampleStartDate': '2004-183T00:00:00.000Z',\n", + " 'sampleStopDate': '2004-184T00:00:00.000Z',\n", + " 'description': 'CHEMS PHA flux box intensities for many species at the highest time resolution',\n", + " 'resourceURL': 'http://cassini-mimi.jhuapl.edu/MIDL/data/CPHAFULL0',\n", + " 'creationDate': '2019-141T14:41:14.000Z',\n", + " 'cadence': 'PT1M',\n", + " 'x_server': 'http://datashop.elasticbeanstalk.com/hapi',\n", + " 'x_dataset': 'CHEMS_PHA_BOX_FLUXES_FULL_TIME_RES',\n", + " 'x_parameters': 'HPlus_BEST_T1',\n", + " 'x_time.min': '2004-07-01T04:00:00Z',\n", + " 'x_time.max': '2004-07-01T06:00:00Z',\n", + " 'x_requestDate': '2019-05-21T10:41:12',\n", + " 'x_cacheDir': '/tmp/hapi-data/datashop.elasticbeanstalk.com_hapi',\n", + " 'x_downloadTime': 4.695701360702515,\n", + " 'x_readTime': 0.0001888275146484375,\n", + " 'x_metaFileParsed': '/tmp/hapi-data/datashop.elasticbeanstalk.com_hapi/CHEMS_PHA_BOX_FLUXES_FULL_TIME_RES.pkl',\n", + " 'x_dataFileParsed': '/tmp/hapi-data/datashop.elasticbeanstalk.com_hapi/CHEMS_PHA_BOX_FLUXES_FULL_TIME_RES_HPlus_BEST_T1_20040701T040000_20040701T060000.npy',\n", + " 'x_metaFile': '/tmp/hapi-data/datashop.elasticbeanstalk.com_hapi/CHEMS_PHA_BOX_FLUXES_FULL_TIME_RES.json',\n", + " 'x_dataFile': '/tmp/hapi-data/datashop.elasticbeanstalk.com_hapi/CHEMS_PHA_BOX_FLUXES_FULL_TIME_RES_HPlus_BEST_T1_20040701T040000_20040701T060000.bin'}" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p8QD-RQXW6Dk" + }, + "source": [ + "# Data Model\n", + "\n", + "A request for data of the form\n", + "```\n", + "data, meta = hapi(server, dataset, parameters, start, stop)\n", + "```\n", + "returns the [Numpy N-D array](https://docs.scipy.org/doc/numpy-1.15.1/user/quickstart.html) `data` and a Python dictionary `meta` from a HAPI-compliant data server `server`. The structure of `meta` mirrors the structure of the metadata response from a HAPI server.\n", + "\n", + "The basic data structure returned by all HAPI servers is a CSV file in which the first column is a time stamp and subsequent columns are data measured or associated with that time stamp. The columns are mapped to one or more parameters (that may be multi-dimensional arrays) using the metadata associated with the request for CSV data.\n", + "\n", + "For more information on the HAPI server specification, see https://github.com/hapi-server/data-specification. Note that `hapiclient` requests HAPI Binary from a server if that feature is available; a HAPI compliant server is only required to serve HAPI CSV." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XI4fUVj5W6Dl" + }, + "source": [ + "## Extracting Data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZFRo76fzW6Dl" + }, + "source": [ + "from hapiclient import hapi\n", + "\n", + "server = 'http://hapi-server.org/servers/TestData2.0/hapi'\n", + "dataset = 'dataset1'\n", + "parameters = 'scalar,vector'\n", + "start = '1970-01-01T00:00:00'\n", + "stop = '1970-01-01T00:00:10'\n", + "\n", + "data,meta = hapi(server,dataset,parameters,start,stop)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GITbtWjmW6Dl" + }, + "source": [ + "`data` is a Numpy N-D array with named fields `Time`, `scalar`, and `vector`. The array has 10 elements (one for each time value) and each element is a list." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Satv6Bj1W6Dl", + "outputId": "f80e3b72-675f-4bd5-e4e0-cc7de530d74e" + }, + "source": [ + "data" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([(b'1970-01-01T00:00:00.000Z', 0. , [ 0. , -0.70710678, -1. ]),\n", + " (b'1970-01-01T00:00:01.000Z', 0.00523596, [ 0.00523596, -0.7033947 , -0.99998629]),\n", + " (b'1970-01-01T00:00:02.000Z', 0.01047178, [ 0.01047178, -0.69966334, -0.99994517]),\n", + " (b'1970-01-01T00:00:03.000Z', 0.01570732, [ 0.01570732, -0.6959128 , -0.99987663]),\n", + " (b'1970-01-01T00:00:04.000Z', 0.02094242, [ 0.02094242, -0.69214317, -0.99978068]),\n", + " (b'1970-01-01T00:00:05.000Z', 0.02617695, [ 0.02617695, -0.68835458, -0.99965732]),\n", + " (b'1970-01-01T00:00:06.000Z', 0.03141076, [ 0.03141076, -0.68454711, -0.99950656]),\n", + " (b'1970-01-01T00:00:07.000Z', 0.03664371, [ 0.03664371, -0.68072087, -0.99932839]),\n", + " (b'1970-01-01T00:00:08.000Z', 0.04187565, [ 0.04187565, -0.67687597, -0.99912283]),\n", + " (b'1970-01-01T00:00:09.000Z', 0.04710645, [ 0.04710645, -0.67301251, -0.99888987])],\n", + " dtype=[('Time', 'S24'), ('scalar', '),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 1, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 2, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 3, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 4, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 5, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 6, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 7, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 8, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 9, tzinfo=)], dtype=object)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 7 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BiFuvnNYW6Dm" + }, + "source": [ + "Access all values for parameter `vector`" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xd8v95D1W6Dm", + "outputId": "32125666-1e33-4a6f-b160-deee2715bf4b" + }, + "source": [ + "data['vector']" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 0. , -0.70710678, -1. ],\n", + " [ 0.00523596, -0.7033947 , -0.99998629],\n", + " [ 0.01047178, -0.69966334, -0.99994517],\n", + " [ 0.01570732, -0.6959128 , -0.99987663],\n", + " [ 0.02094242, -0.69214317, -0.99978068],\n", + " [ 0.02617695, -0.68835458, -0.99965732],\n", + " [ 0.03141076, -0.68454711, -0.99950656],\n", + " [ 0.03664371, -0.68072087, -0.99932839],\n", + " [ 0.04187565, -0.67687597, -0.99912283],\n", + " [ 0.04710645, -0.67301251, -0.99888987]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 8 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gpUxr1edW6Dn" + }, + "source": [ + "Access first element (all parameters at first time)" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c5V4f-x3W6Dn", + "outputId": "b15ad0a0-aa59-4a30-f3c5-076af09e92b2" + }, + "source": [ + "data[0]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(b'1970-01-01T00:00:00.000Z', 0., [ 0. , -0.70710678, -1. ])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 9 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i3u2x6OXW6Dn" + }, + "source": [ + "Access value of `vector` at second timestep." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SfRuSHmBW6Dn", + "outputId": "aadc24ad-3969-4791-ed67-6f7eef537a86" + }, + "source": [ + "data['vector'][1] " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([ 0.00523596, -0.7033947 , -0.99998629])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CKoRfY20W6Dn" + }, + "source": [ + "Access value of second component of `vector` at second timestep" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "piVwAegDW6Do", + "outputId": "82faf274-c8d4-4211-bac8-e3a10ee770df" + }, + "source": [ + "data['vector'][1,1]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-0.7033947028105039" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "og71yLWGW6Do" + }, + "source": [ + "## Time Representation\n", + "\n", + "A HAPI-compliant server represents time as an ISO 8601 string (with several constraints - see the [HAPI specification](https://github.com/hapi-server/data-specification/blob/master/hapi-dev/HAPI-data-access-spec-dev.md#representation-of-time)). `hapi.py` reads these into a NumPy array of [Python byte literals](https://stackoverflow.com/a/6273618). To convert byte literals to Python `datetime` objects, the function [`hapitime2datetime`](https://github.com/hapi-server/client-python/blob/master/hapiclient/hapi.py) can be used. Internally, this function uses `pandas.to_datetime` for parsing if possible. Otherwise it falls back to a manual method for parsing. The byte literals can also be converted to Astropy time objects as shown below." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "bYIrxLUOW6Do" + }, + "source": [ + "from hapiclient import hapi\n", + "from hapiclient import hapitime2datetime\n", + "\n", + "server = 'http://hapi-server.org/servers/TestData2.0/hapi'\n", + "dataset = 'dataset1'\n", + "parameters = 'scalar,vector'\n", + "start = '1970-01-01T00:00:00'\n", + "stop = '1970-01-01T00:00:10'\n", + "\n", + "data, meta = hapi(server, dataset, parameters, start, stop)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zqLUxv8XW6Do", + "outputId": "4d14834d-8d2c-4e22-fb6a-7df62b591b44" + }, + "source": [ + "data['Time']" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([b'1970-01-01T00:00:00.000Z', b'1970-01-01T00:00:01.000Z',\n", + " b'1970-01-01T00:00:02.000Z', b'1970-01-01T00:00:03.000Z',\n", + " b'1970-01-01T00:00:04.000Z', b'1970-01-01T00:00:05.000Z',\n", + " b'1970-01-01T00:00:06.000Z', b'1970-01-01T00:00:07.000Z',\n", + " b'1970-01-01T00:00:08.000Z', b'1970-01-01T00:00:09.000Z'],\n", + " dtype='|S24')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3W6cMLu1W6Do", + "outputId": "0987da6c-1772-4206-d379-c74e1243bbf4" + }, + "source": [ + "hapitime2datetime(data['Time'])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([datetime.datetime(1970, 1, 1, 0, 0, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 1, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 2, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 3, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 4, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 5, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 6, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 7, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 8, tzinfo=),\n", + " datetime.datetime(1970, 1, 1, 0, 0, 9, tzinfo=)], dtype=object)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 15 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WgPeIMDcW6Dp", + "outputId": "93d17582-1b63-4b0e-c4b2-a7f0bf0b4705" + }, + "source": [ + "!pip install astropy\n", + "from astropy.time import Time\n", + "Time(data['Time'])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Requirement already satisfied: astropy in /usr/local/lib/python3.7/dist-packages (4.2.1)\n", + "Requirement already satisfied: pyerfa in /usr/local/lib/python3.7/dist-packages (from astropy) (2.0.0)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.7/dist-packages (from astropy) (1.19.5)\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "