diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index bd2a752c8..5d41d04b2 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -9,7 +9,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8] + python-version: [3.7] steps: - name: Checkout github repo @@ -17,33 +17,29 @@ jobs: with: fetch-depth: 0 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + - name: Install miniconda and environment + uses: conda-incubator/setup-miniconda@v2 with: + miniconda-version: "latest" + activate-environment: btk_py37 python-version: ${{ matrix.python-version }} - - - name: Install Poetry - run: | - pip install --upgrade pip - pip install poetry - - - name: Poetry cache - uses: actions/cache@v2 - with: - path: | - ~/.cache/pypoetry - key: ${{ runner.os }}-${{ hashFiles('./poetry.lock') }} - - - name: Instal FFTW + Eigen + - name: Install conda dependencies + shell: bash -l {0} # setup and activate conda environment. run: | - sudo apt-get install libfftw3-dev libeigen3-dev + conda install fftw + conda install -c conda-forge eigen + conda install -c conda-forge galsim + conda install tensorflow==1.15 + conda install -c conda-forge poetry - name: Install poetry dependencies + shell: bash -l {0} run: | - poetry install + poetry install --extras "galsim-hub" - name: build docs + shell: bash -l {0} run: | cd docs poetry run make html diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index fb2dcf5c9..46518f2c7 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -14,7 +14,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8] + python-version: [3.7] steps: - name: Checkout github repo @@ -23,31 +23,29 @@ jobs: lfs: true fetch-depth: 0 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + - name: Install miniconda and environment + uses: conda-incubator/setup-miniconda@v2 with: + miniconda-version: "latest" + activate-environment: btk_py37 python-version: ${{ matrix.python-version }} - - name: Install Poetry + - name: Install conda dependencies + shell: bash -l {0} # setup and activate conda environment. run: | - pip install --upgrade pip - pip install poetry - - - name: Poetry cache - uses: actions/cache@v2 - with: - path: | - ~/.cache/pypoetry - key: ${{ runner.os }}-${{ hashFiles('./poetry.lock') }} - - # galsim needs this. - - name: Instal FFTW + Eigen - run: | - sudo apt-get install libfftw3-dev libeigen3-dev + conda install fftw + conda install -c conda-forge eigen + conda install -c conda-forge galsim + conda install tensorflow==1.15 + conda install -c conda-forge poetry - name: Install poetry dependencies + shell: bash -l {0} run: | - poetry install + poetry install --extras "galsim-hub" - name: Run pre-commit checks - uses: pre-commit/action@v2.0.0 + shell: bash -l {0} + run: | + pre-commit install + pre-commit run --all-files diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d645bd342..30ec024ee 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -14,7 +14,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8] + python-version: [3.7] steps: - name: Checkout github repo (+ download lfs dependencies) @@ -23,33 +23,29 @@ jobs: lfs: true fetch-depth: 0 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + - name: Install miniconda and environment + uses: conda-incubator/setup-miniconda@v2 with: + miniconda-version: "latest" + activate-environment: btk_py37 python-version: ${{ matrix.python-version }} - - name: Install Poetry + - name: Install conda dependencies + shell: bash -l {0} # setup and activate conda environment. run: | - pip install --upgrade pip - pip install poetry - - - name: Poetry cache - uses: actions/cache@v2 - with: - path: | - ~/.cache/pypoetry - key: ${{ runner.os }}-${{ hashFiles('./poetry.lock') }} - - # galsim needs this. - - name: Instal FFTW + Eigen - run: | - sudo apt-get install libfftw3-dev libeigen3-dev + conda install fftw + conda install -c conda-forge eigen + conda install -c conda-forge galsim + conda install tensorflow==1.15 + conda install -c conda-forge poetry - name: Install poetry dependencies + shell: bash -l {0} run: | - poetry install + poetry install --extras "galsim-hub" - name: Run Tests + shell: bash -l {0} run: | poetry run pytest --cov=./btk --cov-report=xml --durations=0 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b5ed2218b..f3e101acc 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -60,14 +60,14 @@ The following sections are only relevant for the maintainer of BTK (currently Is 1. We use [poetry](https://python-poetry.org) as python package manager for BTK. It guarantees all developers are sharing the same python environment, makes it really easy to update dependencies, and publish to [pypi](https://pypi.org). Given some of the complications with installing `galsim` via `poetry`, we follow a hybrid approach of `conda`+`poetry`. -2. It is recommended to create a `conda` virtual environment (using `python3.8`) from scratch and use it to install all required dependencies. After having installed `conda`, please follow the following series of steps: +2. It is recommended to create a `conda` virtual environment (using `python3.7`) from scratch and use it to install all required dependencies. After having installed `conda`, please follow the following series of steps: ``` # enter to the local repo cd BlendingToolKit # create virtual environment. -conda create -n btk python=3.8 +conda create -n btk python=3.7 conda activate btk # make sure you can import galsim after this step before moving on. diff --git a/btk/draw_blends.py b/btk/draw_blends.py index 9de07d167..af65cbed3 100644 --- a/btk/draw_blends.py +++ b/btk/draw_blends.py @@ -6,6 +6,7 @@ import galsim import numpy as np from astropy.table import Column +from astropy.table import Table from btk.create_blend_generator import BlendGenerator from btk.multiprocess import multiprocess @@ -291,7 +292,7 @@ def __next__(self): } return output - def render_mini_batch(self, blend_list, psf, wcs, survey): + def render_mini_batch(self, blend_list, psf, wcs, survey, extra_data=None): """Returns isolated and blended images for blend catalogs in blend_list Function loops over blend_list and draws blend and isolated images in each @@ -306,12 +307,20 @@ def render_mini_batch(self, blend_list, psf, wcs, survey): psf (list) : List of Galsim objects containing the PSF wcs (astropy.wcs.WCS) : astropy WCS object survey (dict) : Dictionary containing survey information. + extra_data : This field can be used if some data need to be generated + before getting to the step where single galaxies are drawn. It should + have a "shape" of (batch_size,n_blend,...) where n_blend is the number + of objects in a blend. See GalsimHubGenerator for an example of usage. Returns: `numpy.ndarray` of blend images and isolated galaxy images, along with list of blend catalogs. """ outputs = [] + index = 0 + + if extra_data is None: + extra_data = np.zeros((len(blend_list), np.max([len(blend) for blend in blend_list]))) for i, blend in enumerate(blend_list): # All bands in same survey have same pixel scale, WCS @@ -340,7 +349,7 @@ def render_mini_batch(self, blend_list, psf, wcs, survey): ) blend_image_multi = np.zeros((len(survey.filters), pix_stamp_size, pix_stamp_size)) for b, filt in enumerate(survey.filters): - single_band_output = self.render_blend(blend, psf[b], filt, survey) + single_band_output = self.render_blend(blend, psf[b], filt, survey, extra_data[i]) blend_image_multi[b, :, :] = single_band_output[0] iso_image_multi[:, b, :, :] = single_band_output[1] @@ -350,9 +359,10 @@ def render_mini_batch(self, blend_list, psf, wcs, survey): iso_image_multi = iso_image_multi.transpose(0, *(dim_order + 1)) outputs.append([blend_image_multi, iso_image_multi, blend]) + index += len(blend) return outputs - def render_blend(self, blend_catalog, psf, filt, survey): + def render_blend(self, blend_catalog, psf, filt, survey, extra_data): """Draws image of isolated galaxies along with the blend image in the single input band. @@ -372,6 +382,9 @@ def render_blend(self, blend_catalog, psf, filt, survey): psf : Galsim object containing the psf for the given filter filt (btk.survey.Filter): BTK Filter object survey (btk.survey.Survey): BTK Survey object + extra_data : Special field of shape (n_blend,?), containing + additionnal data for drawing the blend. See render_minibatch + method for more details. Returns: Images of blend and isolated galaxies as `numpy.ndarray`. @@ -386,7 +399,7 @@ def render_blend(self, blend_catalog, psf, filt, survey): _blend_image = galsim.Image(np.zeros((pix_stamp_size, pix_stamp_size))) for k, entry in enumerate(blend_catalog): - single_image = self.render_single(entry, filt, psf, survey) + single_image = self.render_single(entry, filt, psf, survey, extra_data[k]) iso_image[k] = single_image.array _blend_image += single_image @@ -402,14 +415,23 @@ def render_blend(self, blend_catalog, psf, filt, survey): return blend_image, iso_image @abstractmethod - def render_single(self, entry, filt, psf, survey): + def render_single(self, entry, filt, psf, survey, extra_data): """Renders single galaxy in single band in the location given by its entry using the cutout information. The image created must be in a stamp of size stamp_size / cutout.pixel_scale. This method should be implemented in subclasses. - Return: + Args: + entry (astropy.table.Table): Line from astropy describing the galaxy to draw + filt (btk.survey.Filter) : BTK Filter object corresponding to the band where + the image is drawn ` + psf : Galsim object containing the PSF relative to the chosen filter + survey (btk.survey.Survey) : BTK Survey object + extra_data : Special field containing extra data for drawing a single galaxy. + See render_minibatch method for more details. + + Returns: galsim.Image object """ @@ -422,19 +444,8 @@ class CatsimGenerator(DrawBlendsGenerator): compatible_catalogs = ("CatsimCatalog",) - def render_single(self, entry, filt, psf, survey): - """Returns the Galsim Image of an isolated galaxy. - - Args: - entry (astropy.table.Table): Line from astropy describing the galaxy to draw - filt (btk.survey.Filter) : BTK Filter object corresponding to the band where - the image is drawn ` - psf : Galsim object containing the PSF relative to the chosen filter - survey (btk.survey.Survey) : BTK Survey object - - Returns: - galsim.Image object - """ + def render_single(self, entry, filt, psf, survey, extra_data): + """Returns the Galsim Image of an isolated galaxy.""" if self.verbose: print("Draw isolated object") @@ -460,25 +471,15 @@ class CosmosGenerator(DrawBlendsGenerator): compatible_catalogs = ("CosmosCatalog",) - def render_single(self, entry, filt, psf, survey): - """Returns the Galsim Image of an isolated galaxy. - - Args: - entry (astropy Table): Line from astropy describing the galaxy to draw - filt (btk.survey.Filter) : BTK Filter object corresponding to the band where - the image is drawn ` - psf : Galsim object containing the PSF relative to the chosen filter - survey (btk.survey.Survey) : BTK Survey object - - Returns: - galsim.Image object - """ + def render_single(self, entry, filt, psf, survey, extra_data): + """Returns the Galsim Image of an isolated galaxy.""" galsim_catalog = self.catalog.get_galsim_catalog() gal_flux = get_flux(entry["ref_mag"], filt, survey) gal = galsim_catalog.makeGalaxy( entry["btk_index"], gal_type="real", noise_pad_size=0 ).withFlux(gal_flux) + pix_stamp_size = int(self.stamp_size / survey.pixel_scale) # Convolution by a small gaussian: the galsim models actually have noise in a little patch @@ -493,3 +494,90 @@ def render_single(self, entry, filt, psf, survey): gal_conv = gal_conv.shift(entry["ra"], entry["dec"]) return gal_conv.drawImage(nx=pix_stamp_size, ny=pix_stamp_size, scale=survey.pixel_scale) + + +class GalsimHubGenerator(DrawBlendsGenerator): + """Implementation of DrawBlendsGenerator for drawing galaxies simulated with + galsim_hub (https://github.com/McWilliamsCenter/galsim_hub), a framework + for generating real-looking galaxies using deep learning models. + """ + + compatible_catalogs = ("CosmosCatalog",) + + def __init__( + self, + catalog, + sampling_function, + surveys: list, + batch_size=8, + stamp_size=24, + meas_bands=("i",), + cpus=1, + verbose=False, + add_noise=True, + shifts=None, + indexes=None, + dim_order="NCHW", + galsim_hub_model="hub:Lanusse2020", + param_names=["flux_radius", "mag_auto", "zphot"], + ): + """Initializes the GalsimHubGenerator class. + + Args: + galsim_hub_model (str) : Source of the model to use. Can be + either a distant model or a local one, see the + galsim_hub repo for more information. + param_names (list) : list of the parameters with which + the generation is parametrized ; this is unique to + each model. + """ + super().__init__( + catalog, + sampling_function, + surveys, + batch_size=batch_size, + stamp_size=stamp_size, + meas_bands=meas_bands, + cpus=cpus, + verbose=verbose, + add_noise=add_noise, + shifts=shifts, + indexes=indexes, + dim_order=dim_order, + ) + import galsim_hub + + self.galsim_hub_model = galsim_hub.GenerativeGalaxyModel(galsim_hub_model) + self.param_names = param_names + + def render_mini_batch(self, blend_list, psf, wcs, survey): + """Returns isolated and blended images for blend catalogs in blend_list. + Here we generate the images for all galaxies in the batch at the same + time as galsim_hub is optimized for batch generation.""" + galsim_hub_params = Table() + for p in self.param_names: + column = Column(np.concatenate([blend[p] for blend in blend_list]), p) + galsim_hub_params.add_column(column) + + base_images = self.galsim_hub_model.sample(galsim_hub_params) + base_images_l = [] + index = 0 + for blend in blend_list: + base_images_l.append(base_images[index : index + len(blend)]) + index += len(blend) + + return super().render_mini_batch(blend_list, psf, wcs, survey, base_images_l) + + def render_single(self, entry, filt, psf, survey, extra_data): + """Returns the Galsim Image of an isolated galaxy.""" + base_image = extra_data + base_image = galsim.Convolve(base_image, psf) + gal_flux = get_flux(entry["ref_mag"], filt, survey) + base_image = base_image.withFlux(gal_flux) + base_image = base_image.shift(entry["ra"], entry["dec"]) + + pix_stamp_size = int(self.stamp_size / survey.pixel_scale) + galaxy_image = base_image.drawImage( + nx=pix_stamp_size, ny=pix_stamp_size, scale=survey.pixel_scale, dtype=np.float64 + ) + return galaxy_image diff --git a/btk/sampling_functions.py b/btk/sampling_functions.py index 73784de28..eb028d056 100644 --- a/btk/sampling_functions.py +++ b/btk/sampling_functions.py @@ -119,6 +119,67 @@ def __call__(self, table, shifts=None, indexes=None): return blend_table +class DefaultSamplingGalsimHub(SamplingFunction): + """Default sampling function used for producing blend tables, specifically + for the galsim_hub galaxy generation.""" + + def __init__(self, max_number=2, stamp_size=24.0, maxshift=None): + """ + Args: + max_number (int): Defined in parent class + stamp_size (float): Size of the desired stamp. + maxshift (float): Magnitude of maximum value of shift. If None then it + is set as one-tenth the stamp size. (in arcseconds) + """ + super().__init__(max_number) + self.stamp_size = stamp_size + self.maxshift = maxshift if maxshift else self.stamp_size / 10.0 + + @property + def compatible_catalogs(self): + return "CatsimCatalog", "CosmosCatalog" + + def __call__(self, table, shifts=None, indexes=None): + """ + This sampling function is almost identical to the default one, except that an + additionnal cut on the flux radius is applied. This is done to avoid having + galaxies too large being selected, as generating large galaxies causes artifacts + in galsim_hub images. + + Args: + table (Astropy.table): Table containing entries corresponding to galaxies + from which to sample. + shifts (list): Contains arbitrary shifts to be applied instead of random ones. + Should of the form [dx,dy] where dx and dy are the lists + containing the x and y shifts. + indexes (list): Contains the indexes of the galaxies to use. + + Returns: + Astropy.table with entries corresponding to one blend. + """ + number_of_objects = np.random.randint(1, self.max_number + 1) + (q,) = np.where((table["ref_mag"] <= 25.3) & (table["flux_radius"] <= 24.0)) + + if indexes is None: + blend_table = table[np.random.choice(q, size=number_of_objects)] + else: + blend_table = table[indexes] + blend_table["ra"] = 0.0 + blend_table["dec"] = 0.0 + if shifts is None: + dx, dy = _get_random_center_shift(number_of_objects, self.maxshift) + else: + dx, dy = shifts + blend_table["ra"] += dx + blend_table["dec"] += dy + + if np.any(blend_table["ra"] > self.stamp_size / 2.0) or np.any( + blend_table["dec"] > self.stamp_size / 2.0 + ): + warnings.warn("Object center lies outside the stamp") + return blend_table + + class BasicSamplingFunction(SamplingFunction): """Example of basic sampling function features : magnitude cut, restriction on the shape, shift randomization""" diff --git a/docs/source/catalog.rst b/docs/source/catalog.rst index 76166fe4b..3e1531cd4 100644 --- a/docs/source/catalog.rst +++ b/docs/source/catalog.rst @@ -10,10 +10,14 @@ The catalog simulation framework (CatSim) is a database of astrophysical sources The btk package includes a sample input catalog that contains parameters of 100 galaxies. A more extensive catalog can be downloaded from `here `_. COSMOS ------- +------- The Cosmic Evolution Survey (COSMOS) is an astronomical survey based on multiple telescopes which provides a large number of multi-wavelength galaxy images, both as real images and parametric models. Refer to the `GalSim page for COSMOS `_ for more details on how to get COSMOS data and to the `official COSMOS website `_ for more information on the COSMOS catalog in general. BTK includes an implementation of COSMOS real galaxy rendering, providing the possibility to get more realistic blends. +Galsim_Hub +----------- +Galsim_Hub is a framework for deep learning image generation models, developped by François Lanusse, which is available `here `_ . BTK supports drawing galaxies generated using any galsim_hub compatible model ; the default one generates COSMOS-like galaxies and is described in `this paper `_, but the BTK implementation should be compatible with any model. + .. Cosmo DC2 .. --------- .. `CosmoDC2 `_ is a large synthetic galaxy catalog designed to support precision dark energy science with the Large Synoptic Survey Telescope (LSST). Refer to this `notebook `_ on how to inject the DC2 catalog into a CatSim-like catalog that can be analyzed with btk. The btk package includes a sample input catalog that contains parameters of 15 blend scenes with 61 galaxies. diff --git a/docs/source/install.rst b/docs/source/install.rst index 23305196e..6744a8c32 100644 --- a/docs/source/install.rst +++ b/docs/source/install.rst @@ -1,7 +1,7 @@ Installation =============== -*BlendingToolKit* (``btk``) uses `GalSim `_ to simulate galaxy images. The required python version for ``btk`` is ``python>=3.8``. +*BlendingToolKit* (``btk``) uses `GalSim `_ to simulate galaxy images. The required python version for ``btk`` is ``python 3.7``. The required packages for ``btk`` are: * astropy diff --git a/docs/source/tutorials.rst b/docs/source/tutorials.rst index 95ec9e4a7..75c723275 100644 --- a/docs/source/tutorials.rst +++ b/docs/source/tutorials.rst @@ -293,3 +293,51 @@ Please note that several surveys can be provided as a list to the generator. In blend_images = batch['blend_images'] blend_list = batch['blend_list'] btk.plot_utils.plot_blends(blend_images, blend_list, limits=(30,90)) + +Galsim_Hub tutorial +-------------------- + +BTK supports galaxy image generation with galsim_hub ; please refer to :ref:`this page` for more details on galsim_hub. The steps for using the galsim_hub generation are very similar to those from the previous section. Before starting this tutorial, you must install galsim_hub, which can be done using pip. You can find a notebook version of this tutorial in the notebooks folder. + +First, you should use the `CosmosCatalog` catalog instead of the Catsim one. While galsim_hub only require parameters for the image generation, we have chosen to use COSMOS as the source of those parameters so as to get a realistic distribution of those parameters. We have included a small sample of the catalog in BTK, and advise you to download the full catalog (see:ref:`COSMOS`) for better results. + +.. jupyter-execute:: + + COSMOS_CATALOG_PATHS = [ + "../data/cosmos/real_galaxy_catalog_23.5_example.fits", + "../data/cosmos/real_galaxy_catalog_23.5_example_fits.fits", + ] + catalog = btk.catalog.CosmosCatalog.from_file(COSMOS_CATALOG_PATHS) + +We then instantiate the sampling function ; you should use the one specific for galsim_hub, which includes a cut on the size of the galaxies, as artifacts tend to appear when trying to generate galaxies which are too big. + +.. jupyter-execute:: + + stamp_size = 24.0 + sampling_function = btk.sampling_functions.DefaultSamplingGalsimHub(stamp_size=stamp_size) + +Then we can instantiate the `DrawBlendsGenerator` with the survey of your choice. Please bear in mind that while BTK will draw the images in any band you desire, galsim_hub does not generate a SED for the galaxy ; this means that the magnitude will be inacurrate in any other band than the one generated by the galsim_hub model you use (by default `"hub:Lanusse2020"`). + +.. jupyter-execute:: + + draw_generator = btk.draw_blends.GalsimHubGenerator( + catalog, + sampling_function, + [Rubin], + batch_size=8, + stamp_size=stamp_size, + shifts=None, + indexes=None, + multiprocessing=False, + cpus=1, + add_noise=True, + galsim_hub_model="hub:Lanusse2020", #May be replaced by any model compatible with galsim_hub + param_names=["flux_radius", "mag_auto", "zphot"], #Name of the parameters ; they must match with the model you provide + ) + +.. jupyter-execute:: + + batch = next(draw_generator) + blend_images = batch['blend_images'] + blend_list = batch['blend_list'] + btk.plot_utils.plot_blends(blend_images, blend_list, limits=(30,90)) diff --git a/notebooks/galsim_hub_tutorial.ipynb b/notebooks/galsim_hub_tutorial.ipynb new file mode 100644 index 000000000..c7b74a69b --- /dev/null +++ b/notebooks/galsim_hub_tutorial.ipynb @@ -0,0 +1,360 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Importing the relevant packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Autoreload packages in case they change.\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "import sys" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import btk\n", + "import btk.plot_utils\n", + "import btk.survey\n", + "import btk.draw_blends\n", + "import btk.catalog\n", + "import btk.sampling_functions\n", + "import astropy.table" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Drawing blends with galsim_hub\n", + "\n", + "BTK supports galaxy image generation with galsim_hub ; please refer to the catalog page of the documentation for more details on galsim_hub. The steps for using the galsim_hub generation are very similar to those from the previous section. Before starting this tutorial, you must install galsim_hub, which can be done using pip.\n", + "\n", + "First, you should use the `CosmosCatalog` catalog instead of the Catsim one. While galsim_hub only require parameters for the image generation, we have chosen to use COSMOS as the source of those parameters so as to get a realistic distribution of those parameters. We have included a small sample of the catalog in BTK, and advise you to download the full catalog (see the documentation) for better results." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "COSMOS_CATALOG_PATHS = [\n", + "\"../data/cosmos/real_galaxy_catalog_23.5_example.fits\",\n", + "\"../data/cosmos/real_galaxy_catalog_23.5_example_fits.fits\",\n", + "]\n", + "catalog = btk.catalog.CosmosCatalog.from_file(COSMOS_CATALOG_PATHS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then instantiate the sampling function ; you should use the one specific for galsim_hub, which includes a cut on the size of the galaxies, as artifacts tend to appear when trying to generate galaxies which are too big." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "stamp_size = 24.0\n", + "sampling_function = btk.sampling_functions.DefaultSamplingGalsimHub(stamp_size=stamp_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we can instantiate the `DrawBlendsGenerator` with the survey of your choice. Please bear in mind that while BTK will draw the images in any band you desire, galsim_hub does not generate a SED for the galaxy ; this means that the magnitude will be inacurrate in any other band than the one generated by the galsim_hub model you use (by default `\"hub:Lanusse2020\"`)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "draw_generator = btk.draw_blends.GalsimHubGenerator(\n", + " catalog,\n", + " sampling_function,\n", + " [btk.survey.Rubin],\n", + " batch_size=8,\n", + " stamp_size=stamp_size,\n", + " shifts=None,\n", + " indexes=None,\n", + " multiprocessing=False,\n", + " cpus=1,\n", + " add_noise=True,\n", + " galsim_hub_model=\"hub:Lanusse2020\", #May be replaced by any model compatible with galsim_hub\n", + " param_names=[\"flux_radius\", \"mag_auto\", \"zphot\"], #Name of the parameters ; they must match with the model you provide\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/thuiop/Documents/stageAPC/BlendingToolKit/env/lib64/python3.7/site-packages/galsim_hub/generative_model.py:80: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/thuiop/Documents/stageAPC/BlendingToolKit/env/lib64/python3.7/site-packages/galsim_hub/generative_model.py:80: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/thuiop/Documents/stageAPC/BlendingToolKit/env/lib64/python3.7/site-packages/galsim_hub/generative_model.py:81: The name tf.global_variables_initializer is deprecated. Please use tf.compat.v1.global_variables_initializer instead.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/thuiop/Documents/stageAPC/BlendingToolKit/env/lib64/python3.7/site-packages/galsim_hub/generative_model.py:81: The name tf.global_variables_initializer is deprecated. Please use tf.compat.v1.global_variables_initializer instead.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/thuiop/Documents/stageAPC/BlendingToolKit/env/lib64/python3.7/site-packages/galsim_hub/generative_model.py:86: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/thuiop/Documents/stageAPC/BlendingToolKit/env/lib64/python3.7/site-packages/galsim_hub/generative_model.py:86: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAChCAYAAAClBOSIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABys0lEQVR4nO29ebR1W1YX9ptrn/t9r5pXRfUNPEqgxASwTRRjB5gIgiQGNQQGEBEMkjHISKMMm5ghOOwwGSiOkKGxQQWl0aBRAgkmDAsNCqIgEiA2FNVQRVFA1at63f3u2WvmjzW7tfbazbnfved+r96eb3zvnrPPauaaa+655pprzrmImbHDDjvssMMOO6xDumsEdthhhx122OH5AvuiucMOO+ywww4bYV80d9hhhx122GEj7IvmDjvssMMOO2yEfdHcYYcddthhh42wL5o77LDDDjvssBFeMIsmEf1aIvr/Fn5nInrzmXA5W1877LDD+YCIfp6834eZ3/8AEf2Fc+N1KhDR5xHRdy78/slE9M5z4vSowAtm0WTmf8DMv+Cu8djhhQtE9GuI6HuI6Eki+jki+n+I6JffNV47AET0ZUT0/UR0SUR/+bb6YeY/xsy/82HaOMeCxcx/jZk/NfT5yCn6d7Vwd7WhDzUgogMzH+8ajx1euEBELwPwbQD+CwDfAuAegF8L4PIu8drB4F0A/giATwPwojvGZYczwHXXheftTpOIfhkR/QARfZCI/gYRfTMR/RH57ZOJ6J1E9HuJ6KcAfN1GreQziOjHiehniOh/IKIk7X0MEX0XEf2s/PbXiOjDAi4/QUS/h4h+SHYR30xEj4Xfv5yI3k1E7yKiL2rG8RlE9CMyjp8kot9zY0Ta4VGCjwUAZv5GZh6Z+Vlm/k5m/iEi+goi+gYt2Jr4iOjvE9EfkV3qU0T0d4noVcKHHyCif0JEP++OxvUhAcz8rcz8twH87FpZIkpE9AeJ6G1E9NNE9FeJ6OVNsS+S9/3d8Z3uzPWvlHl9PxH9cyL65PDbK4no66Sd9xHR3yailwD4DgBvFF54iojeSES/QnbKHyCi9xDRV8/g/hYi+q3y+VcLn/0m+f7vE9EPyucvJKJ/KJ+/W6r/c+nvPw3t/W6hwbuJ6Hcs0GwylvDbZxLRDwoNvoeIflH4rStbF+iQiOj3EdG/EXn9LUT0SmlL36svJqK3A/guaesbpOz75V163dw4gOfpoklE9wD8LQB/GcArAXwjgM9qir1efnsTgC/Z2PRnAfh3AfwyAL8ZgC5wBOCPA3gjgH8bwBMAvqKp+9kAfiOAjwLwiwB8oeD6GwH8HgC/AcDPB/AfNPX+IoDfxcyPA/gEAN+1Edcdnl/wLwGMRPRXiOjTiegVJ9b/HABfAODDAXwMgH8E4OtQePxHAfyhm0R2h0X4Qvn3KQA+GsBLAfxPTZlPQXnfPxXA7yWi9r0HEX04gP8dZYf7ShQ58b8S0WukyNcDeDGAjwfwWgB/ipmfBvDpAN7FzC+Vf+8C8DUAvoaZX4bCH98yg/tbAHyyfP4kAD8O4NeF729pKzCz/v6Lpb9vlu+vB/ByFJ78YgBfu8DXk7EIDX4pgL8E4HcBeBWAPwfg7xDR/VB3IlsX6PBfAviPZSxvBPA+AF/b4PJJKHL80wD8dhnDE9L/lwJ4dmYMAJ6niyaAX4liWv4zzHzFzN8K4PuaMhnAH2LmS2ZeJEKAr2Lmn2PmtwP40wA+FwCY+V8z89+Ttt4L4KtRCB/hzzDzu5j55wD8XQC/RJ5/NoCvY+Yflon+iqbeFYCPI6KXMfP7mPmfbcR1h+cRMPMHAPwaAAzgzwN4LxH9nTWtNsDXMfO/YeYnUTTsf8PM/5eYl/4GgF96K4jv0IPPA/DVzPzjzPwUgN8P4HOodv75SmZ+mpn/BYpy87mddj4fwLcz87czc2bmvwfg+1EsXm9AWRS+VOTCFTNPFrQAVwDeTESvZuanmPkfz5R7C1x2/TqUzYB+7y6aK33+YcHt2wE8BWDiN7Iyli8B8OeY+XvFAvNXUI4sfmVoYk629uBLAfx3zPxOZr5Ekbe/rZmbr5C5eVbG8CoAb5b+/6m8q7PwfF003wjgJ7nONv+Opsx7mfm5E9uNbbxN+gERvY6IvknMpx8A8A0AXt3U/anw+RkU7VNxbduN8FsBfAaAt4np5N87EecdnifAzD/KzF/IzB+BYlV4I4pytgXeEz4/2/n+UuxwLngj6vf4bShKfFSAurKkgTcB+E/ELPh+Ino/imL1BpSdz88x8/s24vTFKEcAPyYmxs+cKfePAHysKGu/BMBfBfAEEb0awK8A8N0z9Xrws82ZYJR7EZbG8iYAv7uhwROo6TUnW3vwJgB/K7T1owBGzM/N1wP4PwF8k5iO/yQRXSy0/7xdNN8N4MOJiMKzJ5oy17m+JbbxkSjOAQDwx6S9Xyjmj89HMdluxbVt15Fk/ifM/JtRTBZ/G/NmlR0+hICZfwzleOETADyNYrpSeP1d4LTDZngXinBW+EgAR9SKzJwsifAOAF/PzB8W/r2Emf+E/PZKCr4TASayjZn/FTN/Looc+SoAf1PO/dpyzwD4pwD+KwA/zMwPAHwPgP8WxXrxM3ODfghYGss7APzRhgYvZuZv3NBuT8a/A8CnN+09xsw/2asnu96vZOaPA/CrAHwmgP9sqdPn66L5j1C0hy8jogMR/WYULelh4cuJ6BVE9AQKU6nt/nEU08OTcg7x5Se0+S0AvpCIPo6IXoxw9kRE96jEQ72cma8AfADFrLzDhxgQ0b8lThMfId+fQDHZ/WMAPwjg1xHRR1JxKPn9d4fpCxNEjjwGYAAwiIPIXHTBNwL4b4joo4jopShK9Tc3u67/noheTEQfD+B3wGVJhG8A8B8S0acRkfb5yUT0Ecz8bhQz/P8sMumCiPRs8T0AXkXB+YiIPp+IXsPMGcD75fGcLHkLgC+Dm2L/fvO9B+9BOb89GVbG8ucBfCkRfSIVeAkR/SYienxD0xM6APizAP4oEb0JAIjoNbI+dIGIPoWIfiERDSjy9worMvh5uWiKdvRbUEwS70fZ+X0bHt59/39D0cJ+EOWA/i/K869EcQ56Up5/6wm4fgeKCe67APxrTB19vgDAT4jZ90tRzkt2+NCDDwL4RADfS0RPoyyWPwzgd8tZ1jcD+CEU/vu2O8PyhQt/EMXM/ftQ5Mmz8qwHfwnFrPfdAN4K4DkUB5QIb0F53/9vAP8jM08SBTDzO1AcDv8AgPei7JK+HC6XvwBFiP8YgJ8G8F9LvR9DWbh/XMyQb0RxlPl/iegpFKegz1nw5XgLykbgu2e+9+ArAPwV6e+zF8rNwdxYvh/Af47iSPU+FJp94ZYGZ+jwNQD+DoDvJKIPorxnn7jQzOsB/E2UBfNHUWjx9Uv9En+IXEJNRN8L4M8y89fdNS477LDDDj0goj8M4COY+YtWC+/wSMLzcqcJAET0SUT0ejGr/HYUV+T/467x2mGHHXbogfhgfBzK7nSH5yk8nzMC/QKU88KXoMQa/Taxne+www47PIrwz1COkL7srhHZ4frwIWOe3WGHHXbYYYfbhueteXaHHXbYYYcdzg37ornDDjvssMMOG2HxTPPxe4kzA2CACSWcnwFiAERlyWUgS1TLIGVqg298yCCSwkxVkQxCltK2kktDGQwGkFhRoPITKTIAZWkvsTXKAAjkWQi4NKlBOKU9BunYQrcZOtbSTpZ+Bm2PUQ+UABzKgzxK+wASE0Zpj4gxJEGCU6EdlUGx0CODkcEgEBJLG+AybiodZQBMhMSMQZobSWjCpb2kY8rlWQbAMtZEYV5QxkiA4MnWL0s/UgjPPBi3JnR4KPjU+5/H4PVw1cKcACUCKAGcwZnLdwVKWni9Y2mj7aNqbytQ0Ee39N3Wa+uE55vGGOhRvtZjaJ9z5lKf0nS8vb6b9r1opx9pd67MIlDCd17+tVvnu13W7bJuq6xb3GkmJiOkEjfST1tlLv/0WUJBloisUKxTYRMfzB2vCh7OFI4FSwMsjybtV80qC3LTxhQ/HxujPfet+rCmnAA8eZliCgqpL3/ji+d4kw5bXgav690xSCa8vFzlv4re7KOOo9enDBa+i3Spx2mEfZSPvucEMl3DkLJShzNXC0X1/cS6S32vlZ37bbH9NRznfjtl0Z+DjW3ouFfHccOwy7pd1m2VdYs7zZGBLKPVwesA7TsDSRVRRIYjQRCiO7HgIm2pJlExGiMzMFIppa9wkgLKlzXfiWYmhbP8qhpE0WZQ4R8JRXDtbiDX1FLRVZBTGHf4/0gF98TAwDIgLgQ3BQuw8ZXhEhhccBT1hkN/lVJUVB8wAUcWOiYynuWmD1dmS1nVVDMK0QiEQWYFTCASbRlAZtdIVcsba1JNXs5bhRkB2+6w7POcQF4T1O3OslO+3RXF74uC/dSFptktTnZjob0lxaClyVw7vXG19K12o51d5RYo7Q3twwqXRbiJBXsD7LJul3WRVkuwuGhGdq0mj1BpOyk+h5sfdDClYK0tGdFs3fdpsn4pMGv7TOs0zBG1Duo8i1AYOrKHMri3RkFjsfYIwhAIGmH5wV+Xml4ptGjjDS+GvlxqUohKnZsN/Jm2zbEf07PqNh0fMoSIgYG4MA2zvYDWh3wo7ZwuLG8LKsG+IHzXzIbtYtNbEJbMiGsLyCm7REoy6Rt3j5Px+w+bFY4e7SpT7RqExXdigj1hx7pk/r62afwasMu6XdZtlXWLiyaRmyl0a2xI1ipQNTBC0UgoaGCBpZwALEgSIaHYt4tdW9SPsGc35uLSpuIzWt/eC2n1gC+S44YcFBwu77gp6FDNZp18SmSlhWlaYaJtHOS1Iv4RokZVM1tkdjK9nVDT3BmFXWvWlzlMno5LaWqth7eonAn4S/IoLJunCNBTys7tsE7qZ27H1/QzW3elz03jWdiVPYzZeo0eZeGcOcPd0Fek/7kWyRZ2WbdCH+yyTmF50QyIZggzUU0A1kKGGDmR5HkCmUZxDEQ2EwQHswLK9h1MGDn0AaMRDigGn8yyXQfZ4fKgHZNoKYpvEr5kgOTtUOLouQS4mcxAvXbSqfkXC1T08dGG3wkH7V3okpms7/I86laxQX/ZdF70RVf6qKkFKC+0mlBASksxx2h5e1/l/+1Y+PxZ5CcOLK3w5by4SBgMQ2GUngNNIhRCjd5HaHPOiUbhRgT8iqmyWrB65uS1RSm23yvbG7N+75Q/mRa9BVSetWfD5mA0V/8WYZd1NS1a2uyyzmE5I1BskAHoQTmFgYqWpcWVZMTFWypqQDpQgMFE6vzUTNLURKCvUUZ9QM9Ua0iu3wUmUKXCOzctQ7UZn4Aw5YHhl4DJvc3akUTGYMFDFRxrl+vCJBNpznINV6r3l0IORYin7XL4BzizVjMW0I+CggJBbmB5OAnM7KdwXeHZ7JKqhTMuEN4xKHUW2PB7FPrX2f1eayd7Ihhua4tsj64zC3G7Gz8Zt6074ZWytwK7rNtl3UZZt7rTTKi3tox6JSYCBlnCI38BhcjHxHa4rct61CsiI0kL4rLs5wRJamWpwE0bigc1o60YlUXeQUwLuoFBkZ2F8WHWhUF/Q13W2ta/VA7zASBJYcePay2OARI3cdVU7f/stYjdBZtZNkMgs4mQum6HtlOgeUSQueyj1B+PGchy2O6mj8JQ1ZmA0ITlr7nPnxmWFph2EeoK8dlztOYsb8W8urpInCDkq3ZWdpiLZWcWN63bxbkTUhPx2rIQsu3c0wTH1bPkDmyhx23DLut2WbdV1q3vNCsNiSvtJLxuxaEqjkA+G3OF+rEDQ7qyMfv/WFsJHltMroVZSy0TwbUM1WLcBOHU1hFxUyc2ztq+DpJjf06T2LxqQhS6I+jMxNkmNEQJ5wT1oKjqpBk3V+9qhXv9xV/B+DJHmrgfeYvBowmTXWkHur/3HGfOJLRv3Mmlcei5dSea64TzTJrYuECfA3ZZZ23tsm4ZVneaQ5YJSACnoJUwMObCABOLT6DNEBgxDjTJgBIHnyxlXDFAs5xiH6noCer1ZExU+VWXSdF3jEWTQnYtgiUK1s0GXLenLQXNxYidfBwk47IpEfNLFgbSc45BB50ApFzay6XfOg5LVL7ABd62aFaqXeoLwR7UG92yowapNI3anbYJFDd7QhFeSX4txUqHOgYGcOSHF5KbQRazWWeajpnx2gvEqUkI5kI5FLcNuLQ7tS11Fs8+l0Jl5jxqSXeJeXln2tBn62K8aT5mzjhj8oRzwS7rdlm3VdaddMtJ+xrQ5ElbyFdxexI0CNNMYrRwXdxg+qiuQ6GfWquAq0E6IRzmbKLRsNeMv+nsBK1KTxlMGWZnTh/wFOvIQPo5o8FpAjWi3BSrQ3a5qtWSde57XbX00JmK5z1cZ4GdrdMI94c+97smrC54C7A4tjPBuZMZrMEu67DLuhlYXDSPIBDl0HH0YiI7tVa7sZqjbQEHYDmpmCXIVIbqapi5SPvAWH6S/rjoK+pTHLUgZcz2SF3NFBniG6lGf2aJDmaTCQdpOmp1I5FpUoBoQAxLE3WQeuqVVfDVaZwe2mvqqxjbZC7q8r+oNZG1a6qiMdoYNCz1JFMyR1s9oWjL6h96BKp5cjU0aqFk9TjWaeLTbxUWHG00vOHUxYiGoWp7ziFmc7zmQpzjmrNQN+B/rc+FHWbcKc7iO1N3M2wsX5nK51IbNm0und+eS+nYZd0u67bKukVVMvJCUDAmK3Jc9YkLGSt3bRbG46JvVEGyQpRon7bcjxQ1vBYDdiUpFNHJEf7sahYxBZPSs83AEfGIz8yrjXjaOAsDC9O243JkKwo4Is1HxclGzNXoS6/s/OZaof9L8INzH3DTYWivBevrPLJrEywK0i0hGFqmyZ6zebdznVR0a7hs6G8xhV8Pbsq8ueA81IOtpuYl/M+989xlneLgsMu6PiyfaTIsQ0OLS3wS3aSBIos0wUmV0UEJHWpXjkoUtDYrw2DJG5UyV4QFGINphFQxnqaLMo1EXbbDS0Hq4aYTJATu8IfVSeQa01HblxekpgNbvbF5cXychCMLng2BlQkylXgvYxKeTjrZ2MuLpGNhlLr6bIiNs6tzVXqvOF+O7jyn3SKsJQiYeM/qbrJ3TtlbQNr8WW2/c+eIS/GRCxl2JgkGti5qC6nv5qt0Qk6a39fa2KRMLGVlGmcIvGEXee4kB7uswy7rsE3WbVo01e8q0KEZSIEcHpg2I0Z10xbUOqbIs7dpuDIV7abp0AgZNA3lDvMMM6KU2UpoZGjoo/refKPwxMfOpq1FQidjJq9ba0nK1EGXlEKjHKyr27WZYMhf2FH6SzJ+ZVyAPTcm6v5H679gUDRRnzkWZuKoXs4w0V0tmhE27zxm0tH1FonFM8eFNHuzOW+3LoRNYvae48umRW2mv9Zcu9TO7FnoNXPNVjjM3JqydvPKEr63Bbus22XdjSyaNTH6v8e/lmIJ5EQWbSEecwCOe7jdpmImZvJA2iAXysDIBphFnRKyWikiZ7hWg1ItpWIm7Ty+JVyPMSZmtuKhYWtHcEzgyswQ2zdcwvsSn0dReEAzB8oE9kKxpOPy9pKOn1UQeMckjM8NMq2PArBivz8TrDnUVItYnsd4bafWjRc85UqrWGdp8eydg17HlDoTt6kxqNde9Nq8stb8iQtZMMNu8ii+Th83BLus22XdVlm3smj2t9OAaw+AZ2qIpoHMxVV5AFWmC2UY1aT8cDv2Gw7gw0wqA6VAAA61hL6OasA1ulQP2gn7zM6LFxZ8SOqSdWJaiU6EqU8FkhBvZAkqBrsrNZQxp0ykWOlfnaQRNZ56mK8B0fFQwdCIL1Ogd0VxrunG5NpfmifMWWCSRq48rH6rnHxmFq7NIRAdU2wXhxkcaRgsPR+PI2LCgCUz7drCsmnxsucldSClXEyklGYdnNpzxVUTcItvq1w0ptfFcJbO2CZ9nQl2WadU2GXdGqwmN5goJbZCa0om9hVaBhIZhSPRpXxpJg66aAdasi1RaTBNOiktqziSfXf1i5oyESEW6sa+onalfSWtHSYh4mmmktAJhX7spaGgeQZ6Wv0oT9FA1I6SZzAxegdcghkfg5hFYhtGI6lr5zJhbAyeJGa+U1i6AuwmcpbO1FnzZK12ZLrb7XjPdhfPFTxPCluZS+DQ4Lr0fStsrbcl8cRsm+fMDrTLul3WbZR1m+I0K+8wdamyWfND4VGw1aBgDUTVZwDbVjyLJpIEQxsEN4RGyO4vvKEzrF5dDD+AvkBh7DGLxkOuiWh7HNorz9UYIeNtNBEfE9uhNttvfiZRM7y0Jf8GQsUZmjZLH2XAbja36tqQjLHSYAl2tmD/QvujlL+ABvOqFlaQZB0okc2X4qGQqZiNiDVt1vmg3ZWtCt4Ni0+Ea5sBZ8IkqrPSxgFmPp3dsF4OC2MPu7s2NaAXueY4m/Ynz5ccjDiXHffgO177rdtNf2G9i9jNXdbtsm5N1q0ummaHbgjB8INZDiqDEtMzUfjgbe+Mor2RFDT7PFc1QsX4yT21yrOi7kR92n9nmxDrvkphFbi21RLlS0zQ7O0w9Jc4gRyaa4ehqbP6YoDd9TzgYOHAkbExdS+PXnraD6mWS4EfVSOrVFVvnFBeqmj/n7iRnwlO2aE8bBKB69a/kQXpxPbmytzaWeB1dsI6thPmr6p7V/lnd1nnz3dZNwsri2ZJpksM8CBdJkWwbGdJsUVJVRSZqMJQiumgy4ovmejN+KxxR35WoJNZxu2DzlQIqlqdqihHkN/MbdzjGhCzu09nYYvSp7Yjh86ahortMdyoInglr69zAy7puIAYmNvJJ5JqLU0vetUH6lpdCAE3hUyYTeo3KqXShUlvhy/yiEBWWKtkduZM8BeFIenDuJsP5dYhJlKP6d56Xpd6dhcX295C0g37kJR2s8J/yau12e3NjWNpp3vyjqp3+XSErR68Dc6roTad+qUYgyzaJ6429Xlnu+Nc3EHPpFG8Pdhl3S7rtsm6lZN2No1DQbUN8hKNNhSek6/+62mTOj9Q227sqUaAZFZMgZMm3S3bkdAJr0wTsV2y/zWYhU/SSIV12wRQaabVcwSaxFbqH8Cguo1WztiAnTm4LcBNJWoGj/AikI8N4EfjLPMEuJEEBbcAcQHYsmCeZcG4Lg023mV6p2M7GXZZt8s6bIKVOE02DcZMEZCVnYKZIJXn93Kxlo+y6gPiORjtGE3MUA6BuDqSyl4OBjgXJSRoHtHLSvUbDg2rNsHk5wQ6HYMUyl4cejgf9Qzi2k1cy8WpYrj80JyQTFSSCUvM1sgsZw5saZ2ymjCsfbXHi56ZXZu1GVYtSbNwmFboWpPFfKkJRjVY4xQHTR/FyUdE0m5MmQUwxjMKusrkt8EDVtPSTRJ+h/qLTiadWEIAk7PJ6Al7Hdgar7hWPjxY7G/WKzbsErekt6vKze1O1/DvOE/NIF31fa4Fdpd1u6zTUa7Jug2qZlC/wqJN9s/t3QnBBs1WpVbXQuVog1a1zpQPahrSQYcm9BOjZoqo1Chxq7rseDZdVMOOqNV4U6Rx/ReY9Gefq8nkpppSszxkq6f/1SRsFSoA07OV0LI2Og3edmLruLjTyF2dbVagaee27JBaU+Nisw85uGucwV3HyWVpEVro6OR+euntFhfsU3esvTlsEj7czbnmLut2Wbcu61aTG9QrNld/1H3ZNR22A+IEGax4n6nOosxjtnjTN4p9P9tvbBM3Ja4zTmtqqDJoICp1bl44OvpAxB81EUs/pVCGhs2StRuZDeQXtBZPL7arZpQeOhiGEyDFDB6TyWPDTwN8tWrF3AF/Tak1kONFRi+u5lQ90lIYL4ff4oH9Ob1n13YhJnSXQj9iCMikGa7qLJ7hzaTM853QdCe8ZZc05xV8kzus2cTwcUwn5pXVdqsz4LUFbsudpROLwjlvCNhl3S7rvOxDes+6OcEIF32BBQYZaA6D10PlqHUQeSCvMssAlrRKrgcEPrWJixpg1GwcVQ6EqM0XQb8Aw80cmhW/0rBAFm8FwG4zH6WxSPgKLaonITJyjAOOGqDVJ5j5QbGP49MyGd5wzMEIVq2JSxkUGhOR0JAbusWXgY3JSworkkTUPi4AoDtw/2+dTcoj6v7ujzYK8ggzqfe67TbQuwPylLKT3+3ZMK3TaW91cV1SCCQJw8Qc26S/6yUo6JmOK0eih90pbnFGulHYZd0u66S/FVmwvNOk6aQxEbLYrZUwV/Zj04AiQR7Oq0mHNZ5GM15UAcBNc5rv8EjTiWhYQJi2cC7JDGjiXz8TiMzDFiAbpz8yNBgYhpo5Gc3fhlDVOyfjNY5AMBz0iGz0cQ87pZHSrsKWlB6155fhQOUUxC+TdQozuSasGq1ZmAIR7sQhaGaX2ItHPCXd22SXt/SSzJgeuyExW5OjL6XmW0hGsJaEvdvfzE6Skidh0HadLssJEXqwWGZpAVxaYM9oot1lnSOyyzoswmqcZhXbK+1mfZKFkWRkenN5pT0RCyPJM8GaqWaeODHKZFkGPmCqvRiTMlUtqJZompvOE5NkwQcuCK6VSE11Ea81sZqZQQCPNYPE8wXtP47F+DMqkUyFEAxX7wLNYluqvXl7ziytW3hRziiUhTH/geUwnMkO7bOokbkpTzJeQ+8uFswGeovU0rVSvQWqKbR6Rri2u+t5wVpKv9ju3K0onVR/k92j5m8Vp6T299537Xfp3lFVPnoxkl3azS1gazvCJdN2vJWmpdEdnGnusq7ALuuWYeVMkySDhFNEA319AGxZFpJMXuWppSt+MqUIMN0jHgZ7Bg3tro2BchIpw1FFZKWmMxODmczTyyZGGKk8ppqAKJ5r8RwidOA8UTFGg6cyfajKVVn5Fl6mWNbG3fquh5dJg6VjPJfiVqaKq1+cZ7lFVzsrs8GBgapBdSudDeZyp86Vmd2VWRbtsGBt8Njstr2AS2x3FhZ2pr32t9DAyq0455x0ZnrCgjhbfi5JfZyPO4Rd1u2yrmp8AVYdgUqwZ6dzYiCViTwIpQoj+Y3fI4dkxOCg8ZC8Q2xeaEcpH7UfCgfrkYkiqKamEzLA8WUGiIWZpEQiYBC38SMXTTK6mGvfI4rWeGFMUYisNnsmCTqWsTPcTdxp1CGojaEMLEd9qebZaQPGYM5M5FznzIr6XAIIWiIxyC72c//rOHZGmQt7HlXAO4BVx52F4PnJwio7NhoGWzgttKS9lSPu8ta8RRcSIayNbe6Ms23vJvLGLi7GW3d3CwvcRPHYojgs7TDPtJjusm6XdVtl3XKcZvNdtYj4e/wHzBEhuP4SJvyg6Y6q/lThYLhnE2Nqbw4aSfvXioqh35rhWvvTb34a4RELVXetltVHpcJdvzLPlIlflUE7bXsZDpoaVUmT45iprYeotfmDDm/bhNi8xjpnhsWFpxe2IObFTblqZ3Y53cVopq9ue6Gd7q5vZSG5ydjE1UX5UYI7xG+Xdbus2yrrFhfNAzty5t4sD0iSMcaFOav9eMKBhJxh2o9OWSlLNoKBirljlMS5B5n8sdlmE1TzADhJO9mpQ3CzQ0pe/oLLhF7JxiIJtyRjbsYRxUxzIS0dWWlRNMWcC44JbgtX92ujg/wdpF9zLY/E0oBc+UEZKaNorwSW2wa0olf1S1c9mFlpyDKOQehT5iRqaGRHDPpyajeKo2rE9lvn5b9tWD6vlAVK3/YNZsvuoqFeokP5POfYM5uar7dwzuCxdgVXhctMWw+9AM5cQzafdCHs5BMB4zh1xFrKoTuH5wa69UJ6bhN2WbfLuq2ybmUjqipDz5o8bZzhWgaTmij0x+nyvbigNxqFj4mCBiZPuRDestqzoxbrarvxRoJaRyyk7ikbUWsqr0GhA4cfq342Aqt6Q9OsjT6GaatljDyhT7eBbqdkGumkaJhimvz4iMLG1G43mdGn7n6aEKBTqMLx1Aw/N7EDXcNxq0m5eWAfN+N4x2eYU9hl3QTXXdZ1YdPVYNpgnAyFDDINQN8lEtcsApeLTG0Auh2n4Fpsio/PLspY1eOJczJbfRw9AaAxokPmhZYy5HBciE6q1QApFTYYxMp+xXLGQD7Oo2RotnMyITzLuz5C6xASSbJgkR0a2zSSlBcje4zn4kzFsazxxotEJhCYGFfk7VJ2Tzt7gQrRAY5akDgpGKdwxTh6uA4Csmi35gihLxORednlM1vOljxE5WFUPXsNoLubCTvL+PyUxcIcjKrMNlNkJm3a2et0Zzd7Btie97UmZZ4msp/zpp2FTvL2BsHJ8LaGv0Qc1ryVTwkbuk3YZd0u65Zg3REIU02lXbFrV2RuynJVVgkJ2NgrF2hvxnWONhFwxdaBjrEfAixmKRrDC8FcwfDJLW1qPkKrQT7BTOShRh0VLQtape3aU816j2jr14agRbdzCmYNos41/WIdjXPSWrV3HreoLgDXn/X6nc31bxB6IRCLprxQbqH8bFD/qbAxlOS0JhfCZZZ2Z5xxrSw6C3GoPdza74uL2w3EX57rTs1d1mGXdRtl3aadZuLadh81MQY7sQdSncEmMcdKgHGlPo+5DYtWxjaD2g+lDGbPasGdf1lw0eTAQBMYy4UoZC1Lpg5JHnyhzCQcrdkmhqgxMcxUoBADZpMQomJmBLt5oOFBy+mGB35eMIT6EI2L4DFc6rGnpGI4TsoyOvYrlPJ2LhE0ND1iGVheuoikvAFG3/PILocTPDQXk7FP6kx3TfHccWvy9KW+5uraAtB4+872s9Z2tXPtL5hLHrdziSLmu6vrxr9zv0dovZLb8d3l7lJhl3W7rFuTdRsuoRZhE7SNyg+LRFMQpIpG4wewUfeKpwXGSIKx5zkkDGDzMjM8SFy2Obp2O4OrBqiMbbZ+xV96q5L2attAuJTAtR0AoFyoqYzayaxVsvoHfUnxIMG3TKJrf0onBoARpoG2mppRRsw16gKehcZRldN2GVxMDQGXKJrKgTlszgjAIG2ZiUOVLoZlELnLhO2rO5oTvFOX7sNc7ePEcJJVeNhg/ibkZlO4RrO7jvTY5HW8YPaezNNMOr7Zdns4ntGjdpd1u6zbIusWF814PY0hUiEVNCkGhrCP1+37EAYIOELuhdZoDqL9OBOKiUFpxu4tFnFRxUGJ5mR2yqh3WWTQKXB9M4DKBFVKGoIWjVFrqpbGVoeFFhwYWieGI+KotUUOnZqtPfRNcragfbaMrImaVbOMdBqECHpeYC81O2nal+zsa2brXLIUFrJxt9fPprPB3NvpY9F8OeMYs2kndUrO1WahOSVG8uQd9Ww53+HOneG2afq6eM14Hrcp/W4Ldlm3y7qtsm7lTJNNIwmvvq/OXtA7BWOkcmg+EEIOQNduAGUMNqKZlkbaBVuOw+LOHLQgmmorai4gMTZogK7hnxqCBIpV/bOWKwfDlhVfJo7gOhwQzBEQqx/H2CLXlnTk0VWbA0JDBpIOWGZPx9i6d+uYOcX5ScXsINygrtoXorWpK3hCmfTCQEEQoBC1MLl71akgOKev41oavOsuPrHNmJbOfh+GqfCeCdPod1nv1Hrp8CYwlzThugnLQ/q8Vcea3tmrhpcs7fJmdrBzoTnX2pUvmLBvA3ZZt8u6rbJuQ3IDqiYM4EIA1MQyrQLKHkHz0LJBdfGkwX6oS3GWg/rFIJtEpfN0YOycZS3XjGMaG1PVVumKq6a0FXWTVtRd23ENTbVF5aCBykfTogIlKTRPzQm7lTVNLf4ea2r9kFqKlQZa193VoyYF+JxYiwTTDtlw1X/6Ql5D8N003JSpbmOe2Vj2oc/botPQkoPMllCMJXN0MId2c9luwVN3d3OxrXO/oU+ntVCdLeVuG3ZZt8u6rbJucdEcQNMVHw3RQRhk2z1mJ6CWtfvcjNotScgYsfxzJlLbvWoSA/nkJXZGBYomoUyCQBJL3MSqHTlBB3jsT2nDJ1MP4RWxcojPlbfZIN0pTZQu5RCbStoqIIy7zp8IGQfBtaM4eeXaGgZRcqQj5RlIqjHZSEqDOrFxfOr6PtovBZ9RxqnamGqUJH0o/c4Fq8nWpxXK36WA+abMUq7YU4T3lvsvHypQvwktoWGYTepw6oLV8x6uwkhm7i2dq7va33XgTPGcu6zzge+ybtp/hM1xmnG1jtpUsWWHUU60nwYDDhMUmAhhIqLGhFC2fG7bIyDcLBCrRNqbHiOIRZ2mNOOlTRNkNO7dHaFUtemNl9HU+hOjmHJaLUp/Y+mU7AE8rZY8i+OLc1H5yofmtYze4ae4xRFoxhKniXKPp64645rpsGV3dkpbLZwptdwpDkYntaNm1OsjNun7pi7BntwdWh52UJhxPrrDlHq7rKswq4e7y7oVR6Dms63vmkIKXOzvOWpPjpFeupohGlT7jpMkFBblVtNPxSDhSMeo1UWtUIkBwYkh18OwbM8JcnVP0AA5mD2EmwllPhKFK3qC9jFHzKKFpXADjqYQlleJiiblNwr4UXaWl0C1r0GrxTHKCX1mQvjZ5iCxeoVFqkkb0mciMaVAPMc4lqZq/lgmO4OLqYKpaIBngqX7ICe/z8GMk4zVs9RwqEMhOkH+S/3MJUDvnmfOnh+mWkFYG08Erd+2v7YYzzhWVcnuQxTL3LnkprNLXdw3hJpUzlRn5Lld1mGXdRtl3eKvXcJFhKPx25Bi+9eMabEHbp42YguuktSPJ2qX9R9aI64IVffQIEj6h8JX/z8BIcFx3eoE3xgsG0jVjm8yXmkypq/i5scpjbjCNZYtMUqhBkesGzYS1Tgy67Sv24dHIWbvunCruN9S27O7vY0m60Vnn7MH+Z4Ou6zbZd1WWbdsns0IJgWoMmEqUJJnLNG9qZlvBjBK7SRaUUoNUszIrCmMAhHCuEi0pzwWDS1RTCCcbfDEwBCYpgZVxQpZGKiCg+MQMzxPhV4qq5rPRQIoMXImjHLIXsqzpcJSzknVhLmGBbA7AmgVVW+Tvp/k45fDDDOfxHap7oMBN3NQSFmFEvwbtU5u/uZAd2WvISse5xN8bQagdpc4K8AXEoF3EyDMhDN0E5hbQvXaw3azObMNCVFttkl4oFKKiMxhQb93m63U6CbWMXy3K9GasI/2nlBvKr6L7sm66SLwNvH8nPNQe14b5nbpAu1bgV3W7bJuo6xbT26gSAbtZjJN8qh3lU3Ucdpp4/A/5n4ZCBPFwerBLYcy4JrPTXtRl2IG2hPeaiTNsLytehKTBDizpJjwySDzuor6TDSLlMNuhBryqaOoTmOkatz8ob/pUUuyGDGCuWF3WSHWDXgUMwthRlbfPty0aW7JE3Tu+7khLJj6t1oUky60M3hGB6G4CJ+407vpxeqUPLW3hcOmPrHLOmCXdWuwfDVYHIAmFNYnjr8c+LpXl9rES3Apm0YTmVG9mNR7Sc8CjPg6k0IdgihPgw9YtZuKQiyeX8KBDP3u+FI1nQ4E4AKFaVSTtBeBjaVK35CCYcz62wFy4Cxai3mdSbJHgr90dgbBsMDe0l7MosjWc2HiZsgAjoLvID+YnKQwZ1L2Sp4MVF6F6JZdq2Lucn92C1vYKa1e87UULK9lm53VyVdsaSjHdVK/tSbOnkLQLJjlWQLpApmSS7PBX4LCgaPXTal8zzUjPGwyg7ny3d1pk1h+i9fwXZvjd1m3y7qtsm5x0UxRpUGtEViqqfbAlt0hmIBJLkcdnU6u3sNWtYGg9YBhCY2VylKoEL9GqrhsU6X5WcyUUMprRNzJchaqiSRqV/pdJxNU5UKxdE8EhLyJZSKYp6aKSVwRhVio0K6+vuWlc8YVS0L5zEErrV4Af/l1PjIV8wsRWzBvzBtmxwGBs6JWdw7YFFt4auacm0igvoLH4n2XK7GVE9Bdpf5t1eBgv7KFVhZWIpIbJzbO2lZadsa1mpM3hK3MpdlbgnMlbN9l3S7rtsq6xUVzjKNqB25ffGJyQ6iidYXtMsFSNR3i3MrfmHKa4cTWyW1f6QoX1CwC9joeE8SC57QeQ5hFuYgUYWcfwH/SgFptNwu1y4tUZiEjm4ebvwmRWXx6VJOML1OuxhOzdDj+5l6tDNbSxgjpfRfekTGrrQhsL4IOPWp558xtsJoG7pQwiQ1C/hTv2KX2e+eF3bFUV4oBSFTOSgFfDFO9mNAws7hkLueVkqT7WrBVoTjFOzfWmbMY9No8Facbgl3W7bJuq6xbDjmRqFfNeFTccX3DrxND8E5No5LPY3geB6JlwpmwEUAvoVCmGw5s2ol5pAOBhP6sHm+Z4BHlRoEknSuxi2lE7mIDld+Tsxyp7aKwTdDKZAK5/B1Q7psbc5bUTgxmRoYkuhLEajYK5w+AnQEoHbNobQh1WCadBV9JKBXGz9XLpnNgzESKsxOKQVAzSkLZtcR4rTHM8TlhKexj0+5ji1Cf+b13G8cpmXVi2MQWhxZSxpKF0vkujCURkDpp/jTKHpg/69Q2ZpxwNgxo2lYMlZmtNkOzpb7bM9gzLZ67rNtl3VZZt+IIRNqVaTaagV41q1iSms8EdAJG1e7PQSWre006DKl3rJhHsNA2dYKaNlRLSlQmQM8TtI04R6r1DSAkSmLnL5kpKBVDgl4la0dL2fsueIgPGhOIi95U4on0bSx/SnYP1aQCJhpcC65MQ05PSXMlsUQ+ALZC+nN4ap9ZKK9tIZQlfcGkXZJnWi/O7bngWingbhBmr83asBj3kpl3QculVM4v7YApAbqz1F2aBfml2jkIAOFQcCIXrDSOwBAciaJz0E3ABsVl1mKwZEFoPZrPFqu5y7pd1m2TdStnmo6wpkkqjJSRARyDBqCrt2LuZSFaiNKr/HiUMgM5c+igBhn0UVy2rzJ5WRl9nROS64GSM9KBVauAaSqmT0ilCyoaFFI5TB9SwuFQhBgl1RPL34Mq2ZmRR00oJUmZcvEaS1y0qQMDibPY1hkpA2ksuB8lsjdlpRcJnYXRXF0DyRXqXPi0THZgusivdjiujCCMa2cBTOb0oCI2UWHSI4osTIAkVIYJ4rOuXbIwzTqdaPhHB6mlhTZeNWXm0NinfSw7y/barMUd1pxzz8KuSR139BwSiYDDARgG0OGgheSlEAmWM2iUdpiL4w+N3rZq8SmVspZns7lE9Br3XXafb0lE36nfv3GGpjQ6E+Ptsm6XdVtl3cotJ0GTovq5a0K+0reajSpXsaxqSlV2fPYfOSgXNe4kjNnXBQiotZao9ZE+8pehfKNg0he9RAQYpYSUEobhQp4NICRxwwZyzsiUZZLIGIeJzRur4JvAyMFOXgsrMwe1dJsOpRqrj6ku02vD6k40M64aVq+2yqjf0ebODnOmxW5Rqss1Z46cZ5xSOu10zcCnOKbMxDBOIIl0GoayYKYEXBwAIrAulvpvHMsOWExjGEWX5gQe5VRrGEDjaAtndBaqdqnXNX0+TPrBTrKEKgvRXVkWsMu6Xdb1cWphedFktlX3IC2NKIGjiQgXKDR7ILrDBXxCM1RDUhuyYBNWc00KPHKZXD1QH2VyB2lM2xuIMJBoErlhTtSEzEKUnJTByOKjBun/ADUaFNZKiZCGhHQYkO5f4DAc8JJ7Lyna2MUBRAl5zOARyPkKOV+Bc0YeR+QMXB0zxpzxIB2RmUEjidCiwkxy/w6LesoAsqhJJCftBdfk42J3b09ZTA7Jisg8wS54zVpHCJFkriIcVRtV7Q5y0M8ZAyzUuWLe8ZyXgy0skGu5TKs2osNNENZ6R+Oiow7g5tktZ5tbvXiB4vgTd5lDKgvm4QB67D4wDMiPvwh8SOCLAUwS9zYycMygcZTPJQKejsURiK6OwDiCKZc+Rjmlybn0lTMs9pOnY2vHMzlX1hdnSXFYTHs4tzsfZ+frXLDLul3WKazJuk0J222iTKMhRyD8ripVvDstKh2medkPfa2SEQvWOGiJjqI1UVNMsyE5QC5RrJOxqS6mxCMq9v4hDbi4uIfDYcD9+/eRUsJ4zOAx43hMOB5VCyOMIxc/DCLQKEYaO01XSnEzkGYUQa2igFv5lSc1JjTrbWw6Y53QTWjV/j7t4G7h5F1IEy84J9DPvbvpZvchX0j5MCDfP4APCeOLDuCBQEcGZUZ6MCI9IPDIIpyLoZDGwG9JJBIVg6GB7jxvEh5mcZsLObnDJBO7rNtl3ZqsW7kazDsqm3OPNwK759fBsNF5Ky69mZvsF6aGwW7SNs8yAsZEYdvs7ZslSmKYYnyOaVuqmYjHm16xUwqRxwWJL7NqKsbPpokAF5TwonQPj917DK965Stw/7HH8IrXvAYX9+9hvLzEeHWFp59+Ck89/RQeXF7h6aefxTBmpOMD5DyCL4FjHpFT0a4GAJQZTMk0KVJiJUjiZDKPuTHDsluw0F6BlR6j2uOD1hWGMnRoBCF/9N6zTwSwCDA3J/kLS+cUZDPJ1rtJDqRMC93FkPzyaX/UeTXbkJaQgm4tuL8b7K9noVpHzaXBYxYAcDiA710gv/Q+Ll/zGI4vSnjm1QnjfcJwyUhH4N5TjIunMoYHGYcPXiEdM+jBAB7LeOk4lp0nERjHsgMYBg9LaWm3gRZ2/ssZfDU9i1ysv/AccNrOzeW54jR3WbfLuq2ybsMl1N5oy75lvgnUDFSX9Uoz69Stzl9VW6PgUYaiFVUaA4fyrJh5m2kSr0ZCp7gFp9CDPiFjNIJrX/fu38f9xx7DSx9/HPcfewzjg+eQj1dIQwINCc888xwuH2TkdASQMY7AMJTsk8xyKkHFLKZnS8x17+XFqGOQSlnXkCratyqUD8keRRK1zEShoNGO4q9tjfMIrs3QmhYnP98NvnN5WE/yohoSeEg4PpZwfIxw9ThhfAzIlwQ6ApyAPCRcPEMYLkfkREhZzWGpSBYq55omkXJ80WZgQ5rBtbPHTYkgOnl7HwXYZd0u66Yd9mH1ajBbfQPxAwnK/60QGXKiWOBC6yijCPck5bTQHmUlANvgCO4lpQWVUIokAeUMx1GqEt0XnNh+J2Eu9ZjzF730nhkYR8YxMy7HEQMzDhcHvOhF9/HiD3s57h8u8LKXfxhe9rKX460/8VZ87/f9Yzz37HP44Ac+gPHqCDBjPI64BOHII64SYxwyOJM7bpgKWVRL9boj6BlIfaktQTUs14jiEJMNvNCv1ZVaZqzbj/M8k644rTPTjUFjtlvNOtNANzn7WltbYcP1YZOzUg2jaFPlMRdzaUxcMBbv2HRkUCbkAzDeZzx4GcAXjPzyK7z4Zc/hubc9jtd9330cns24/34CXeWyK7oay7twdQTlDM4DyiGQm2aJOrMcFzPdWTcexqvxpnFn3bQZv89ZDqLHsv5+LtP5Luumsu43/MiP4L1PPIH3/apfa7Lu2e/4dnzUkx/EX/iwl79gZd3qmSYDlr4pxrPMgpZhWHApw++Y08rkualKNogMC3o1hhAthQSRmjfIHxLMpF4pIxx1M0+vVL6R3zbAqM0gYm4ZmXGUv2lIuLi4wMsefxle+uKX4E1v+ih85Js+Chf37uFHf+xHkFLCc89egpCQj1cYQBjHsdwhl8jOmUxXFccBEFv+SkAPsxHSUflGJcppFbOZdDROB6MT19pvq5Fp+wNCG/BMJ7U5D+eFm3IMWRHU+tt1swJtyjC0lC7OtiDJv2eAxiJYOaEsnI+PSC+5wsc/8VP49Nf+MP7C4Vfj8sdeAaaEw7NDMXldyaJ41F2met6Gs814rtnBK97oMhtisqSExPbmdpYb0ufdBeyyrpZ17/+YN+O3/PW/jn/x838BXvrrPxUf/q//FX75D/0Q/vgv+cW44PSClXWrO81ih2cjcFCaDFtuETatijAywETm6USAbdG1DwuW1WYl8bHGJyUZSB3TrUIQXoZrIur4uelT66u240zIIGZkHnGVj6CrB3ju6adAecT7f/q9OD7zLNIx4/jgCh/10Qmvfu2r8drXvgavf+3r8OT9x3D54AqXz10C+YhjIqTjEZRHUE4SH0SiBQYuaZJVxpclakQAmU0/aplhqPJC1CmmCFMeUP+Agby9qH9qm7Xr/blXTe14XmDfFNzqbiYuDplLfFwIATEi57GEk1wdkS6vcPHUEZQHPPazhOGScIkBxyPh8JEZv/xFP463vOpj8cOvfSXGxwjD1YDhuQQaiwfocFXOMCnJwhc1Z0sAT9NEAoB5F1+bJgvzE6/9Wvr9LmCXdVNZ90Ovfg3Gz/5s/Nav+hO4+pmfwZv/0l/E//Lpn46fevxxvOTd737ByrqVkJOiKxB0ErnqzJ5kmElCtRgCSnqkps0kA6GAsQ4mobRjmpr8ogl7fYRhoCTtgQHJMchcD9vTYVXsK8wq7t7SHyMj5xEP8hVwBJ576oPgqwd4370LXD71FAZKOB5HpCHhNa99NV7z2tfiDa97Pe7du4f3PfUU0mHAeHUJJgY9eFBMFOKhlikXZEXdYkWgUZOMkTgyDVeOA15ex9yZFyvR/CBlow8KNZUmzHcXi2Yvh+vDLpynJnpfKDu3a538FtVnWTgrkJgB1vCRB1c4fPAS6cEBL35RwtXTCTyURe7ecMSvuH+Bf+flb8f3v+7NyPcSLj6YcDEwhucSwAPSZQJdyVlqIkzsVxGveJ9nJ4Zy0RHrFGiSR8z9dlees7us68u6f/6KV+ATP/Mz8dF/6qvxni/5Ejz9xBN4zft+7gUt65bNsyxxRKpNCRKsPdEUeQ3YLeQpme8JruxqMG94hZB04pUZQ3sgTdnk9WMZqv8nzEiGKBviZAxocyFjYGh2CNGMmEFjBtOIB1dHAIQPPv0MrsaM++9/Enlk/MRb34of+IEfwE++4504jkWPOwwJhzTYpJSXQ6YgK/P46Kj56zzSXu8T6EtkVjf1tKvmwIdaz0sYtzUqNFVnhGg6QVO2FQh3AucWqD0zYm9hCbA1KUIr7MAZGD3uki5LtNjFUyPSyDi+bwCNhB94+xP4ysc/Dt/93jcXz1igXCGlAXkr/Z4EN0nvOZPsLVkPToZd1nVl3Zvf+S684R/+A7z7d/5OvPKbvgkf/lm/BT/7qle+oGXdivcs4yiNHJQ5VGsA7HZ2VRzV9Vk7Zfl/QknflIlxBb8qR+JfobZv0zrqcTohnT+qwWp9IrLcihmoEggX5mbT7iBal7o+a3aIkkINSMci/J7Fc7gcrnBk4OJwwPEq46UvehJjznjb29+B4n1W+rg/HJAPGkbs40u5xNghF7ZRTVaZxogVVCAbv2iXAMApPFNacFDGCHbreoIzpJkvGoLqvIUQ82YeKARqn2/Z7DmDxLO2pbCPWE8+yJ+Z3c01k7pXbQC+YDUhLWUxbMrrblOSDjBzSdg9ZvCxOPAkIvDlgPsZ4PsD0tV9XL1/QBpfjG945yeZsAbkzPOCJnk8oTTL4smY0hS/DTBx8Dlhoavncn6HOZci8Vwetrusm8q6T/iZn8MX/8t/ia/9lF+PJ1/7Onz0Z/5H+Oy/8S14+jM+Az/5ApZ1G0NOhDBxCoNGxlVJvxfNzRf+VFuy7XhA3m3T5Mg32kWtmgEazKsZNqLmQRXjeSSOtcf61FU6zdyfcy7Pc8mqcry6Apjx7HPPgQA8+eSTONy7wDAccO9wgecun8Plc5d4cHmJ4/EKx+MROY/InJGZJY7LndkVX7bXACCJzeIKSS/XDt8O/nUu/MM0uiAKAC0WteowD0216u+jCLPxkQpRwG9Mx7cJYuhLMLtuMmNmFlsZgJzBKZX4MJVqx7Fo7w+OYGYMz14AAO49SRjvUXEQugCGS2C4ZBwuGcODXOI2j7ksyJJCDxC+bhMbnHqbiO4Wb3hnWC2MGj935nCUXdZNZd3HPP0svvJjPxbvfPGL8ar3/jTe97LH8eynfhre8Pa34/INb3jByrrlRZPcIyxx8CdIZdJHQU4Z4CBbaeTy7ABPSDwKc2iAr16FMyZIkt+y+icmxOxlqlmQDpzCwFnTUqm24cQw3JPLBv3NZFouDzSUThWMMTMyl2TX6QogKlG5KSUcxxGHiwt84Nmn8d73vgeH4YB79+7jOI545pmncXU84qkPPoWrqytcXj6H49UVHhyPeJA1uFyy/mcAKE4DmYFB2V20Q3NCA3AliB9knKPUYYJdW0AcGEsHC9fKOHKJElS0uWNWgSD0Qbm1IINLGioALV/eJsx7pJbB9sI9aCjXZtlvK8HyveTg1wZtJydnppAcfjaelBkUUtyBCDgei7s+M+iYipdlSrh3zOD7Aw5P38dL3jMgXxDGe8X55+LpjPQg4/D+S6TLK9Czl8CDK/CDKzH51gtmWUBPXDDnyq6E4ESFZi0h/MnXv90g7LJuKuv+9Isew+F4hZe+7a0m69567z6OL3kpnvmpn3rByrrVRdOwshkKBcIExcckAyNpgwGoAZpCPa3ZrvreXt1ZDIBtUJDP/q1S0npUYGcc8ExNBlgSP47jCGbGg6srHDljoBJUPgwH3Lv3ADlnPHd5ieM44up4xHE8FjfsnJFZ7p7TkbYqTXw59LuNyAgY0JsOqKc1Ued5/St5X8EkQX5Qc9bFsoXNKe6usWPc1Pap4S66E7umwGdm2W2WNhjiGDQw6MFVSZSdykKZLxLS/WIKOzwzltjOB8eSj/Y4ymJZFkyOkvem4UTFgzObqfNRgl3W7bJuq6xbXjS5pIhiuJZlKzEHZtGXQLQxYg/SHRu6eToqducqLiv+AZK+Svyuudl321BNHYtkIivD0LPoct7oBJX/j3UzR6lVIo/I/2MCHwGiwgxEBB6vACJcPfMsnj0ckORqHc6M47GYKI7jsfx9cEQex+IViWzxUEVp4mqmRyq+e+pGDbC5qCfxKOBU6Edgi28ChzMN2KvqF0GJj3kixsBsLu4AgCyOC/IKWjy+zBtRSfRc0f5M0O5OZs8t5+IGm/jMye/ht1Xz7kaTZGljrOv3PEPjWZ7uNsuXIrjUVAuAj0eACHT5ABgGDE8fkC4OZXc6lF0BNGH75VUx9T64Ao6SvF3T50kf7V2cS+OaeM02u+gezdZ2iF0rQkjTd2p7NwW7rNtl3VZZt+FMk8N464lVl+AghoJWI4Nv3pFqW031RwoDWdfMpO9WBoR/1r8pVGx4QfvTOKmAaLLTaMGYUYwLBLHVo3icHUekBBzkst9xzPLCyTU641huCkCJiTIUhImKOzpLHbl9IKJrdK5GbR91XmaUy+qzxn8RVCBwVZmaeaw89869YjawuGCeWE8qVwL6JgRzbGPzDrmN28y5pL/LRSyUWM4iEpi5LITHI+iqXBuGQXa1Ko1lh2ALZhC0k8WyB4Eum2lyk4kK4ryc2at2l3WC8S7rVmH9Ps0OliwrM4nRPoeRk/WuCJYvusLru5ilEAkSTMXl21U1mlzQkikSF1YfALJMlMYp5TAdSi89szCekfxTbVyOjk+vUIo5IUueTyDnjCs6gojES070JYZpheOYBa9yoFC0Upbxe1/gouEpDd0zsk6XpepiyeJhihUIjKEZQ5KD+FFuwdDkybDxU8GFgSPVbt/FAxC1W/aZF87V3eUMxHMz3xU0Z24aNtKeg04bOwnfiMMixIUmxm3GYDJZOFWNJm1zyHWS84jjmMt4xuxnmD0HoAk6PDnjnd0th7PapUQISzv8TuFpX+e+Ggy7rNtlnZFxEbZfDSaTzOFZV3ZR/UW1KkuqJG3I2bBpGyOJnif9FJq5zqfzE12xLS6IPf9gNQEd1AgcElNwU8fTTzGr9icsIvYaTUfFlAvjI0EDjZUxkzCHepKpGUJvOnfW0sliS6sFEjdtciayl5lCHY6/hZdOGEgxH8Fg5W9p3+kRF5IwtxSCr8+8WEZoTXRLN5J0FypLKqAuBVXj5fcTIjAqPHo7obXdUVwQ1nZoutjJQmoLJbPFZ06rqJR2r1nkXDv+zCQumIxN8aw6aBY3zt3QHg4LazXGlQT7d5kRSGGXdbusW4OVRZMwsCMR28z6PyqalX7VcqT/pL5pVkwTJjTNJn6ZYAKbICdKzQqAy4ZaC1SiqibozwCVL1qRfKJQJwMmBrL4dpvuyGYAMEGln1lmXZ2vmXkSf1W+ey5EZZCsKiDMaWwydqWvtuNzROa5dwDZ1TmmfUnTOTwkRVxeVotjipLjjmA2hKR3QXWEEPvXbSOnfr0OTBbl3uI492xtEcqpnG2No+1WdAG0807dheoOdAnGYNIFaseklV1w2XV28FwzwU52qTPePjPezEtlzgO7rNtlXZiABVjNCJQE61E7jkzDJUfgQFm8vci34igH5MSl7DEMEACSlFT7dhyo9+LfSvBsKTGSE05BNSfdOAykZhKfXN22h7P8cL7O9sdkjYwboY5NMAPkLmkBF5lK2e8bM8WJrs4RgsYpk8isrunFnKIxWK4eyR+WqqHtEQTiYsJIAW+EMvqiaACxTqvSXwVCfLYqqG8SFnZsXeeUuUVxDeZCQrYI9ogrUN3TGXfIrWNSdwyASUBuKM2CGq2YWKs6cWfZjjF+p+Q7w1i/dybbptNrlIE1p6Gq79BPVSeUOfu1Ybus22Vddz6msJywPZxWW+M6dtWiwhgLXciQsGfMYdtNMql+BQxDs2UogWr0636VKZyQsYxqgv6c7AxAn+p3M5EEiIfYRCyamhcqiZnZJ1fLImh15Jj7mPy3akwBf6WbZhjSzB6Ggn10vNnoHMZNRXBmLduCPLJENZH2DUkmZyN3DLNp6q4BWx12WjNxr57i1fX6XIhHXIXgLDSLX7M77UJvl0tplpa9sZx8E0zb9toNKWvt3SLssm6XdVtl3fKiaTzONuGKWAqd2K3jqaZSVBiSLPNOSJlU05Bkm81kd81peTla9hsASIJi4WmRVKPRrbr2mwEcueCtEzSqoT9pP04lgmpf7JMq+Kn1nP2R5eAemPGY1L8qpv/C1ML8KUx4JqUZlTKsdJAgaZtYYUdy5iHUk+1MJIwk5wP67qjpgWwsME1slAYO8HaVBvpX57i5oOBs0Atr6O3eevW2ml0pRpgvtNldsMPOjYYpTl2HmFO9TeNubYqU7Ua7ptcZT+HK8eeU1HUbrgvT0BvrZ+G6sEcFdlm3y7qtsm7lTDMILKr/RlDEdctd6RasWE7r6F/bejdVIe3WKkEp2Wpdk4Y5amQU+ol6mZe1LlRLEryrfkz7cXu9tlvhMiNzTAesGKWYJOw2BGO4elBKxjhEbYElo0WrOU36D420tDbcdFxBQ419fyjBtUy6J7R9rR3xShahbvmZq7aq9paglwN2rc+Ftidj3xJGcueL6S7rdlm3TdatxmkmYxBJCM0eyyRn4xhEpVKvK9UkbO9OKLcwBIO0aknaU5aBMthkgJkCxO0sh/1+TFasuCpecRIGeIrPzgwVrQTu6QWCmQFUawJRsZ+jZnqlh+KiGhU4MEvUdIJ2k1Q9Es3qQCVH5QjgypCrWUdNIkZTFkdJAkZKSKzJpoUrGa6eBmYXhdpeKmUZvaUhEmkU5mx9Q24VVkx4J5sLlxIMNGdos/UavJrO6s8hJKMLvXZCOrrFxbw3lrnfO+23z+bCciIOc1eFVU0NteOPnpXOnet6czypO8H7DLDLul3WbZV1J3EkVV0XSrlNe4qEKV0zsoMYfl7QaAL6tToEDxpYzGLvyl2t5lH1r/9bC+2xUMt7cWr99nWu2pprG02ZSXtSUZlU8Tb6sNKJoZ5qQDChtCMkCs8YFiilnplt+Q5+oemzw607gwTT4Y1moGkF/RbBf9u7rJtu/4baexTCTHqwy7pd1s3B8pkmE2BxN2WETKgvSkU4ZK0GUXJMqqc8j2XImo1Cy/r5gSToJQnWJclWQT4Y0wRFTVIH57Lll3bZJ9+YUf8mZd6aSGMYg+J2iFoT2A7d48AJCNooI96+TgCOVEwJAxdCa+LhgpvSwRvUw/rkjSNJfYJrhR6wXORxApt9v0QCS3A0ocT0MRtOGc6kdiYi7ZEwmqbjykwYRTaefqHUw0Fv8dJdy0n5aDUmsgdrAfhbQ1t6IRm6s4vXabXtVk00Y1vbXbag3qrA4hnolt35llR43IbrdPBVM23XszbCDD0KnIfzdlm3y7qtsm41I5CpNxyf+eQDBKY4bVpFsJPTVS3SutRbm4E5LUtE6Dp2EZm41mIKVvF6HgZq+zb5pMT+tLC1Fxh4Tv1o8QgKIUKT3fK1Wkp1F41cS4CZM7RRDm+D39Yefw/NGYEjhstmBmtR533DOnVrcOp519rO7lST30aPz+tC72qsarxrcZIbxjNr9t1Cq1MX4C0JHtbgDjIC7bKuHlqEXdY5LC6a5gWGwgA2bNV0qLlQVRkgdH4VGyQnstY7sp8XkLRxTzoyG754mGU5QSZExqJqoFmeR62ulGIjXDwbSIClrNJ21RMMTJU252MorFrG4RTW9E7q5h093jQGSk0Q9kLWc2vACC7qVOhisrWThFLxPGqRUVJZUXwpilfePaUD1zRSGEEeAxYDvc4Is7sSfdaLDVToZeppYe5cce63eUSX29zQ1tzis3iBcw/a2MyA36b6oc9ear0IaxeBWyrD1OCy1RHoTGeZCrus22XdVlm3nrA99MK6Z0ZYnYF6Cw2yctF1l1Azi+KVYbvsghCVWwEYzhRRaTCGNm6UD1QTvx134hCH46NDGFBI76T9lUGYBijMFQsRedSQVtMJGqROJn9ZEgzdCk9lqBjbpAHWGudl3npWKfyVz5rFYxjF1JSARGSpvAjFzTtD0k7JMF3ZkiwhKLcQ1E4MZ4SO0NweQtIpF02XG+uclN7tJnZGMSHAWrktC3Qvhd1MvGb5uK4ZbU5Gv4DrqrkWG2l+g7DLul3WbZV1y+ZZtfHLIGxyuNbGlOVVK+u9elFZKvRgIWi5osZMDNn7anmlVvUCAwd9JsEDbtVzyvrnehxxPK3tX+crBrwq/rFki6tWqjSs8LdidO1X7Ccsb1ixs/tgR8QXMTghVGMpTw8yEBpgGUriuLUdcIz7aughfZQgbK7avxMIHq6zu5+5zEBaP/cXjRtx/Nm4YK4uwornjIdqVe6aZtWuh2zj7dvNR9vWmXQXFpbejrfTT/v8LmGXdbus2yrrVjICsQSDkk9oJAJco6AwKi1L8AmySdBiuW6j3MKmeQvhDCeaCwjFdMFlhCyE90NmNs2O4NqOdm58yFOTBcUHWk4Q1QTEIwi69y+/s2tEYUzUmBMseFhpKrQc5UW6yIV2WdpMVFJocRiHmiEuqjGVAprSS5nkIOOwl2kkP+cg0TCFgZMOOklZDsxGfshfXoAbWFyuA01ISNzpLO1GJjui2E4TzO/l++EnWxLGb8IhPFfYsoCcvOvqxF1a7GRwbprgERSPquxcHtlOf5P6naQJ7Q5TUxB2x3kmM+0u63ZZt1XWrVxCHTUc10R0HDo59g7IjxTqV3VYvNE4IEl1WWWeyLjWXiBSaRD+QbWLMN42AFYZJMV27bTcCUbCHa4Twl2kwxjLTQZUjU+3+iTfwTrR7C8H/OJaTYFmKlHQ29RzbhAE4ljsVgTTsLiiDXPAniINywQ4mWIZMo8/xVtJtKJ83Tw0u6npAhcQOtW8FwR5LwnBTZkGe6n25mBuYV7clW48g63GOtbP53a00UN2poD3O7fz3TgvN5ka8bqwy7pd1imJ1mTd6pmmMot6ROvkZ0jKJldKLFOGTsIA2K3bulUfc/l7kAnV1EdJ0TbNgSo8TFWLmDE8m0Nz8q046QF1sWvXg65eU2FENQ8MKDhk6XfQyAGGeaORcIvaxlV0HZiUqwAuFrcs2swgjdi7kNwoEKG0V5jnIC9fI9ptTkqwcimgdMgjKg2N4C+ZBW8rLnH9aXAwTM/ol1GZYWfCE7q7uDbMoylfivSF9qSdUHc2dOIU2OiMNJv4fOw4wi85M9lXqp7T0BYPC9bWHLkxjGYlO1D5aT1U6C53mcAu63ZZt13Wrdxy4ppBVA6UoSh8rqrEETcKJNnJeKMBhHrcVI0MzFAmoaqOeblZXZ60Z8pNC3F86Kb9FeZpnMgFGZ3Q6BkXNbqqfPNRtUzXjgQHDucnPXykfaML+8sjSmGpSxBtsE2q5cjEw/F2+owuzTzeNZy6cD3s7vGhd59bziHn+rmtc9fenZg3cL54Wzv3W4Vd1jmGu6xbhPWrwZqGIgMpJGEM1bD0R/UU02dExVYN0a4yS1onEu1ItAwSDc1OVEoHxfsM0b2ZjAlSo3UdZdpVm4ozZxMXxgTAkhzHAZL6aHMkg9rV9bog01FlrMJwGrcFjz/KuYydSVXXUs/PU0obidysUckgggUWA2xBxKo9atkstvsLC/Z1bmHri0WD9XmF0CxLmYOUP96Vr8bSGd+Wy5K9Uv1b51orhybZ+FI+2Jm0fOVjeFk756uxTm/hionPJ22049J2VzxVV03bczTdkiwCWF4w27Zn5mJLQv4bh13W7bIO22TdSsL2QFgUjSYyEMUyC9WdzF5nDq/Jyl8jAoCqGKlu11GV4fphT5Opem4K1JFGdbs2LtPyCn3U/Vw1KzR0m3bENrnz+NVVFCN1A2/ZpA+FeRvdyxukpmhPXXw+wtxi97Dmv41nidetvxmHE5IbbN719XadK/hee4cZxnCnu9Jd1mHSyy7rJrC4aB4QiKIaVQdHrtDSa29q23o5eA0IMexy0BZP1Y4OOkFcetDD84FKyirOjFHs7NlO1gO+JDFLQiTWnpoxGAPIv1JnOqks48+irqi9X0366pGVRxmDanDhbxKDvb1g8kYdqWhkB3gaqiuh24XQ6Ari2ZXLzQSWnLllJi4H/Ek6ZeIJoxkzyTwAAGdnnUSFLhZAjPNBdZ3UkqBeMDmulgvPl5MLjDU+EkfJ49jfPba4rEB3N9qYTde9cOe9T9fGVpVb2I3HHfmaR/BSv7MQ+7yDEJRd1rXldlk3B+vJDQBJY1RmJl4A2uolYVxeN/7eMJGMedqQDkb+jkEz0EN0gjM3wGEb70yk5XQrrtR0hSyob432ETVFwy88ZHluMdCROeDjK+VpgjdZI14no0Ynh/EiPI9fqJnhiKbPgXvHKaM5bl6mbogrWp1z0bxRWAiuLz93RrZRcNtiNnODyJb6W2DrArTpppZS0P9u3G1HXDcnOLjuAngHC+cu68KXXdYtwuKi6emQHMsyaDls1ckSV2TP6tAc7FZ28zAJ4S9Bzwt84tlMJVThwQzLSU3xFBgxZ6EfAcfXL2b2N2ILIgR2VAXPUZBK+ixFnlMtphB9EGxVCxuZkEEYQqZ9S0yDop5l5iqWimUMTBJwS56eK1eUkIgyLjRIhhdHcljarIRoqghjIo2nYtM4VZdTTbql4Vng1IVupt70587C0oM2BdxcCEybkL23IK2kojs53GImkUOblKDAOF1EZWyc05QObc5bnED79vd297glpvWOEh3ssm6XdVtl3UpGIB+gP9Tf2AhpWkVQZlSTIBsaN+2VGWNJhVRpDKZC1FfBeGUu75aZFQq1PG5H++UKeY4fKMRKOflDca4IaLZ8Vu0peGgRgdjzPapWNjY0Ich5OTkVLK4JMvms7tcsZgM1hQTBZeQhq0fMTeorHyojWuw5tCGsR3Ijg2qjZuJgyWBy/ltOurBhZ3RymrclaB1Uhs5vN9LNNeIUuzGQ/UxCczQ5NTPPySEjHTx6ZbsZiM6829xl3S7rtsq6dUcg1PNoWpT+xt5JWempXO8ifsEc6sUA4nar7Yl2HaLpnqF12ScEjYbIMediYdyE+MzLVtk75AOF3/U8oy3n7bCxksb4ePus74l7v3FpU+3m9YRWj+yD4p2rMoHVXZ2q6Sl0Zu0bchZi7ZSKI8NctJXW+lqbFohHA5aC7U/JsLMpi9DSGehMOr5uOyfAmsdod8G5iexBtwBz2ZhivOtZnKSuAbus22XdGqyeaWb7FP6ItgFZrI/1+ISAnlHQzACCafUMjq0OXidV9RPVQtQ9WBMSj8SStBfCvDrxjCP5VGnAr6qIKXYbGYh9W88NBykj14qgb+6dwcQ5gNjyKmoQtNKqBENzCKIm70oZA25S0CfU4GIaJ6EytQCw8Q/SzhFsN7Inw7lM4EGxs/bJfh/lxR0QJvi2YWaXcW1z5gbopelrf5Mv2xpsk6+v3YYyc3NLd6xzYSXDTLq7jsm1X6x/RnvK+WWLb5tOr7dwxp32mvPTbcEu6wJuET8b5y7rFFZ2mkbW0pxoUGDVgaRv4RJ9okxDcK0gpp0iTOO1I1PVSoh7RMU+oiYFRnPe62qJprOKk6QXy3Lc3rMSk4zZqx7JtaXyJoQyDMvwX6EO19BsnKRtOgeTeAi0NGDFX88a5G3lJPjYm1qQKAovGT2cuSHz4aYhGxsJ43Bh/vimVFmv7hI2muoeRsiq4L6JNG+2W83NQrlk0l3x5F36rdqlbrmweg2WsihtvWEl4NZaCJZofHfp9HZZt8u6bbJu5RJq8pchlZY1fZT2lwNBbdsrqZNKItxSQIN/zTSRnTmVrmaGCAQtfYhFWmlPvp02xhacBhu8e1GNgTimuUg7ZtqWHwuDcZ3xAvUY9btqggMQsusznO1hOOj3FKaRwZPJsslnwii4HaWFAxfGzKECQRM6y3c5f4mMpO9LNAElAgYRsFdc8E6ggE8cw5mhF97QEdZr+WW1rU1lKPmZ5coudzHJwNKurkl8sJpP99TdXuwjXPd1ijKh5Vtv2R4Oy8kbBhvDWprCRwF2WbfLuq2ybtWbgeBb5agxICCoBPPVXXQg1RYA9wKDT4p94+qb9VFuA3CilDaBaB8xjzIES7sSjikQonBbJMqEQMIIIGF4qhWcth8fC8tzZWBTiNoBY/Io/FaVI/3HlvOyacqqaF9J+0RgnCiHq3FOn8f2DX+b1UcLti6YqzuXNjvNwyYs2OggtJqY/YSsOzOFNuHxMLCam/Z5Brus22XdFlm3bJ7NahOn4ElVgm1jx4N8SKphgVBuOi/1RmZcySQO2bWwuLIXGz6BiHEQjeKBMSTMfl0fAjdaGQC9+2awKXU8szCtu26rpgOfkaFoSIN0eSXC5wAJoE1aJ1yYKm0RUjkMz+X3kTw4WDs000p4eRQXhM9MXIKhmS3FFFMImjb7CCFloRk0dVWZI6UzUOZGnPCQ5bdR5aqcfegLqwf6I4rmSiiJlM8Fk53Nwg6z2u30zvQ4l5s9aCW8ovm+NVjfcQ07vI3nl5NnEeel3R034SIL/a3jPf29tyjPmYBp8D6rXe0GU/QcPkvny7cGu6zbZd1GWbeiElZrcaX1NL+Y9qVaSCxXW5f9aWwHoOqAXRtXza3zGnfxbfHq6SwRm/h50n+ny0priZ3NYdeeqFeN1JTrdtkmv/SGw1d5fZmqJ1O8ajWQOxrpLMwheIdw19dJPRRcYzd27vGq487WXfCcZ+/zY552WdfDx77uss5geaeZGJkDqlyYYtTOudaGXCFgUAhmZYKlmzqI+qHeYVzGUpwNAdNnCCVDBJO4WnPQZKJxnDOYytU9AJV0VASMkncwIwSrpmJ+scBi+as4Or00pJnLVTWBJJkJmYp2d6FlrW65vpRFu+EpD9utBYldiXJPunLFkAbZco1Uoa9puP7aMIArEJAKW6qyynBvsSw0J2akTK4lwv1V1CySZU6Y5NyEZ+XkrcGN7DDiOWWA6iqs3g4U9Y6nbdPqhr+289tCqA2ONMtOP82g4jnmQzhNnUTzjeO8TtajOwmb2WXdLus2yrr1OE3lmEb10FyEOjD72ZQ0rhSPwhheR2msmhXJ1Dnbsng4iQ6l7YZ+LOOVFzOdhBD6iEMxVasZYsC11CnfBvXQir/JwNSdOVe/OmO0GTnsc2CIOc1N81lC+jAtiWq6VzQJ7WVWuky1q3gW0AWaodkjArOmxZ6HarPIde+ObBeaG7wia3Me3RaW6tyEh+x1+16q08kgdFYcHrpPYJd1u6xbg8VFMyG4QNuEu+eXjioRG0EZrR4cGSRoFFQIqlqZ/FgNpDAMQ4+q9ByhYg7hKo2V0mbiOYL+U63Lp73USShaT0lQXB8yq2ammlQCSqqoVLTCyDAqyrQ/p4DTTumYyeOeAGAAI1HRkjR5MQkSWZ362vGHTsiizApSmsLrWJWjavwa99XNwEFU/bJqzrlFaM+2Zs/yNgha20HGWzVmFqYqjV6NUFWuwqnpq8LtVI9e645rM+naQnLqoh9iLJd2y6spCFfia6typcH5ds4Mu6zbZd1WWbcpI5B3Fjy0yImjLs+jMJZqU4BqGl7SUJOGkkyc2fKVUoo4udZGOqJqUE16KysH44aWkXQ7n60FJZ78YzcbXKFm3AP7QXMmVBqWtcUBxVa1kw8e51S+J7AFJmfBpReYTAhNIbbBTh9v1saq+Rh1ZoxOVjzOL7lThPxyV4vmrFOIJg8AxMc/deu1SQK6Z3TTTucXuTkz6tpCMBenuSEtYFV2Zjd37aTuHbqtOQed4qBzCl7Vrrw8vJPz0F3WFdhlXR+WE7Y3Nv4abcdWJyQ1A9aEKMWVW19Sb8S8qmRCbFKSkMXtGaWc8mB8RlURpEDmRqyYnVzTTmmdLAhUbuLxszfhDCgM1Zbh8DcRzDwBnpZRmpUiFHJYwtNwBbq0abS8sTKYHN6wZLKnf/CumUaK5xtXNFZ0maLZ5HzQ7iq7QnoueUAiIIddYrP7mXh4Li1y14STvD5P6aeJ25xLV9eFuZjJDZ7JMZPPVtxOhc3juCXYZd0u67bKuuVFE5qZgW3AOlgbEFBt2Sk8Vy0iPrOVPzARyA/KY7sx4WBkD9WkGHaTIPRamUFKjlIyZvNQmhuE4NiR1UU61I/Uk3Foho0BhJThh/dgMHMIhiaxxwA0kjGGnoFQpBlROMQPqa8YFb8c5YcDu8ZqZJJXSLXbQxJdij1mLAyl0FAOA/Tm80Bio1fw9r4zmBXCW8yc9nmc/b1KQ8cZPI7+fa39BVPm7AK1ULdNGNBNgGAm4dytO9mxRZwXcFhb7JbCQTbdHtPcdnJq2Mttwi7rYtld1i3Bau5Z3bK27WiAKcg7qzQoyWyRFWn4iq7Ixp7IkxM2fbXfnLE4/G4ED/bpXNWbapCQkqpj6pmBUlJfHNUkCTFomWGO53Jw7e2TaWp2NN2+fRGP9gWC0ykeZMcXTV9QfaYH9Knqh838YEzGbrKIZgh9ZbNRA0aD5xW0jj4bM+tUZ3lbztQeZje0kBmowmfu2ZaQj1uCzXlogWpx7J2V9kznd7HLBHZZt8u67bJuxRGIPYUT6qBOY46w989CFdXQbEwV8UuZwaqRIWzvWjOILMV8ex8mSb6YdWMoWoe5HRPcgyvLtIqbdLkJvR5PNxCXgAvp/wG7CzkaxwG1jSuhMk3pYC7g1TimY4vMZZOpGpsyGWmC5uIArucTxsUkOll0iYffApBFQ9M+jtLFGOgxGCHOB6ee17UJBuok4Xm1jdXsPN2++mVi3xMHm6aNVVz0hVDbXy+JQF05IjLbx9rvmxx+pI3FsjNnsGsJFxb7viXYZR12WbdR1i3nnuV6hXbdx8fVulq3f9m+s31H+KTtmDZRIeCN2fl6ox1M+g51YsXKRBI6acOhen3rVz9ML9pibIvi/6Uuc9NoUJdq92m2PJfo0bNR4CJqkfEi0yoe1XepWdUlBK1T+3PXbZ6jz6MOa7vFtQTqi03XC+D0DLbeaV17AVAc78AZZhHna9LuTuIvN8Iu6+qvu6ybh5WE7ZgQVCGT2NjJCTwIsxykitmuCSDmahgsW2dQQFxGHT29mL2NDAlU5WKjHgkl/RKAxGWzTWw6kJWlLF+GMkt5LFpIQjCVVIOWj2EiHkiZQyqBviNEllGYaJlJ0n/SXIlHZ+NGncCW1n6G4qxEOhB4AZWhyhj+cgbNyRiLKkeAgbj8RsCVPNSTO9XCDvIsU7l2hyCB1GcCOztbEc5zO7bNsZErZ4qTtoAqbVysQ8lxjTd2WP3GE7R1Rpr39g00mHPmWRhPO64tafV6HsE9p6PZHfOJHsaru+YzwC7rdlm3Vdatcubcomtag6O71lRVeak0N38n8ywcaE7D1ODJTpRKNQlA9o+spSV8dJQ9WMr+RAzTuFYUGGciQ44ndIrnJK5t2WgrfO0zN/KgQiTqYlONb9LvOeGE5OePxC6mk8vWFpa48J6KaycudPL5hmCrA86tOurcUcL3Xdbtsq7qdwaWzzT19Fu1BhZ+DvZ4Asxmz6mUPeoMMoAsW3vBLL4ODNGOuB6ObueJGxKJ+SGeI5jmY1qsTgeZG3FGUX4GObQwz7fQuPFbh+HKOFRblp45AZkkykFep1CZvFVXrWTTUTF57F80OaKiYam7t6lUSpdRNTsy7VO7MjrKtLHOm/VDFlCcGvomuKuA+poOob27gt6OjRK5d2s3dlF8DdfO5byT+fIryRI2DGCx7d41XFX5XsYiwMJrzNt3Zlc7aaszpq7JecGB6lpKypakDLHsGRfPXdbtsm6rrFvkyjkX6qoMGvdr5zsvGyYoTqAzCPm/0Ffsw+aPi8aXg+ZXmgieUlovaCiesDdoilHFMLWO/at80CuD4vvhPtCO4yy0RANqZuLOL1RhWpUpJajulGDa6HzXTiP1lKtwYIAa33PVTDtDuFXY6vwjhWcXwZuEtUuSb3L31Us+sNr+2iJzwiJ0E2OZbaM3X/0GHhqHrbDLOuyybqOsW84IxN6AzTH5H32kgcED+QF4j3HiwCr3ZIbZohkxa0YZuJ4f6BRzJGKOc0Hy/+JdRSQDlLJZs2awJDgW9S2xGyNK+kW/Cke1KLLEyRIsnCT2h4Jw0CHJi8OhThh4wZdkfMbTMrrsZIlX3Wgzhc6l/BF+Qa2OX19q/QtJV4XYl02M9FOhz9Wn6EZ/TtjkYdrZLfXMoTMdzPbZLti953P4TRbzuXbD7rGXqMBjRxfG0La7dlbY8b5dvAZs+sOkn6Wd8bXM0Ldsfp7ve5d1u6zbJuvW0+hxmLjYOcrazPBDYp3w6NoLqm3oOihrfvJ/H5inXzL2DCWdEXXAXrrcEZeEmUh+P7q6VzEyy0gUZ0vCzMG1Gly/PQCoTZMRZEp9JiCH3NKm0qGqKs1b/Beh0n4JRTMikMVRJaDO7AGetKdB10on17jYbyiwYYUXVjiMZfgx7uvWoUlGsDnnaii7lpXn2jupuSxCjcBfXGA7i8FNmzvXHH5OyloU8RWTcM8EvIXmm1IYtn2eC3ZZ5/3vsm4WFhdNMzs0NCwDDBqLcFcMUg3KkSDu2gSxT1qGa14Goh4kOAEYPuGOjWel4DBooVNkN3koE1Al7yXrQ9vkpo7+xEEdpeZvLAqhTxyOvQpUT6gybWf41qYdMaC0y0KbNjtJrD8KbtYyB2rInxgc3Do3KM0njgfngIdMyebNcH8RlfjNrQvHago5abP7rHeeeY3Ueacu8mtj0996Y5tNz6fhL80OObZXlZ/ps/t7q4ycefHcZZ0SQIvtsm4OVhdNTJCtZ0gH59/YkLTAWC3HCCmgCgPG2CeHOlnyKN2S/UahTJn4sVItBOLMgs1UUd3GrsE5XE90DR7Yqz9GJk1aL2hNpRDLmIvGlCGZ+AMtrSjCxAkOSrt4AG5zoK8UhzkgIGt2kuzl/YV3Gul8+JvhBatsJx2y3jXMmju9wKSsfo6p8U4xQ7YCf8m8OW1rnG13bufa3alyxuQuzRW8l9qde1aFy2j/nLum4rnQmW7bc/hpzuBxfbG/LdhlnTe0y7plWFw0hxCF2zgu2bNKw2G4bRth5Q7amBJsenVNUweNHkSwmCBrNECsR9A8h1JK1JAkiGhmDyUYxdYkircKsg2NK06t1sVc3vsyATU329l/7Ec97ITZKmeCSnOrA3TbPj2VF2rQsVeCIMPMT7U8kDkiZ+Iw/grvM8FcPtLZ8JKtu7ct5TYkPl+Cdte1uMM6yeTcVwxuEnq7TkFitvyNpL+7gwQOEXZZt8u6rbJucdG8FyYnU50yihCDSoP2EQZif8JMjapDdZhTGSwlbogemAMoXmWVSuFt6d/ICGrrPsj3ETD3ZMTyYVIUbyWomTmoMBMJMWJQcBLCjNaM18mifZlsEBt7Gsk0SNOi4OclCZreiduU46Vt6d9EmjSk/OzMZNkjyyfhmMiymhw5h7pKv7OeMK1dD7WwcK0lAW8dV3qOLHNleh6ts3duAuBxPH3X1Et2oEkTNLHCXDq9BbPnmpNTXYUmtJq0N46G1xINKxw3hJxM6HkmD9pd1u2ybqusW/xdU0tNNIeAsysbQgYNPDL0vDQDtiWPHtDVa0xa0p2QW82twkG6014b7+i+5iCaRiS49lK0mnKKkRFPM2okqxeoGUjMkmFaG9V4aBn3nNMR+BuSqr6pascZWMchbturMjqqlTVRoiJXnR1ELe9RgBN2elH4b1nAbjr/6ckOR61JeOFM75R8uqeWW00YcVPOTI8I7LJul3Vadk3WLe40j+zb/MwU4l1Kq/Gm7DhhMa1SltnNUk+1GMsMJpQxN2RxLyYUrcMOgSkcpNN0tdfbzDMUz1wRJ+vEgpyJZFIyS75GIpDgmmWwqekoyUV16qFGgN+FrGUkzZWaOnppGS9y+XuEj0vpkXiQdtmoHf9NGjNqx1gnZc0svxJGpELrmTVHNVMCcMHl7EQTG58vYk6RuZ4z0JrXaruTiTujuQVz0+KxcE7ZXuk1V7ZONL9hzHMJ2k90nlnyOJ5zglqqM2vines7eh5vMH/fBuyybpd1W2Xd+k6zMwCzPAdjd61zhbKdVZ5QE5fCh7r4dAZivRa3WJo71NcckNQpH7UkbdsDhDEhgn91rWku9ZS1V3VXVBr9b6lsRWXpOGpeJTasEXbhr372dvpUU61OBj/RB88GtyE0o1CeW1S2JlhXE+nD4rmCx3z3K6rwGeHGdpd3dCWYdb/Lul3WoT+vLSw7AsFjY7SnpM+hRGdjLNVU1J7t3k6Oil6/ooGqcnfpxNuKOySombkMetQ+9AooaFYHtu+AZv6XwYiNXe3+OckBtspB8tifYSyaoV1cEZqx7xSf+4j1ep5M8MtPZUijnMob9Ti4lDf0ZTlsGASnMcFc15OVK2DHR0ondUcjyKWy5Rc1SahGagzK5QJY1XIHqTHegZye7GLmrpqKl0U3O9Qt536bEyJ06lQJ1WdwmO17xst3dgfZlut5ofae93CZaXMt8cEshL57u9DufE1249ffLT8s7LJul3VbZd0iZ2onms2BJr/V3ztKQFWACJU5o/yL/68ZyM8Ywla80jbINCr/udWJIjtGxmQ7oK80DPmgTmQJgnPP0M3+x+zugRksW0b8Xcdm1QO+YTLj2YrGTJlHHce6hTosBTQh1VzMkZ6LzJ0HKBOrI4TRZosKdoPwUMkHqq83g/giPicuUtftby5H7Vz9U++wXILrjKVn4u6FoESnobuCXdbtsm6rrFvOCESufenwtaMqqld+0e1ubabgktWBag1oIGeAbCu9Tx60D6AcuDOBG/sHkaZZikwSdb0wVarJBJzVhq3nCWRjKz8kImdMmdl4sar1osyXa+MDhw2QZrigipKOd5vIGeyTmKRD9W4bye3uA5xhK+IpIuHFGOIDuLar7VtANgDKZeQPRIKcdc3seVEC2LyDgwvgLZ6bkwVhKU7zhDrXgoXzzLnzxWrXu4TfibgthfZs8tyda2+DklEloT8H7LJul3UbZd3qoqmaQ9SB9JC8IBimLQaZEkwjUGSjq7MRjZyoeoMAscfQAFFT0fbJ2hhSIGQYbtEYii5CsT68vxGFSdXVOUO2/DIpZSLJNZ+INzx2S7su1djHJSqQmi7sPWgTFKOZqNgJkZgh/Gb5WjML4/c3vh5zhxEYqNy6SV8yIqRc5oCZLdvGcNZVcwqLCQ1OWQyaOyInbV4Dr+vUb29uWVrkVvuwchKaspS0oZdhaOONIqemzev122un208zpluHXdbtsg7bZN3ioqlbem63wDoaGYTZ+dkZTYlgxWVUFlskHk+m7VSDQkWUKsi2+tGnQl6xxnW5bnoUbWrIpeYBABPjADK8Wnt2btrQrTwgAb6CBttv5EzDOtmaEKpMmDKkjZ/rSbePqm1peZkDpSWFOpWmBkw8wIzhA11VOUySfHoMbSdlKqm07t59uxBjB7emvuvC3O7xmmdop+TFvS6s5tNduai7l3ygOmu8xtgnOC0pMFt2lpPY2POeae6ybpd1W2Xd8n2azHb4WgZBxv/ueUQ26DgIn4ByRpB1FBromh3hwJc1G7AzUfnNVbJovtBJBDR1lWtnVkYnHZ6wOEnlAcU93NkzMiiFCSJLlzWQH0QDZXwjEaoIYGlQ45O8HXbLQixOfYbSl0210yS0l6MOK5rQmF6UVuFfbL6UZRvHqPM0yY6yJSbqBmFByNZxl30nmbiDW4SlxaK3y+tc07Waii+0tQRr5s6uo9DG9HtzYyhfpzvPSSo8cdzRfL2zkAiazH0TzIXgYDq3tw27rNtl3VZZty33rBKkWe5jWqPwURijTFiqm7BBM4WyqsJoOw2z9MbAzMK8VGlIHOoZhB/j4bkfAFNXA2Lo2QSJN1b8OTCyEEbjvGIzxGQZRGz83DBNIJ734ecVCeUMJYqRqG1Fd3ktQ+xYEnM1R/ZcxshhIrXfdt4SNzR9BKE683uYnd+Gs9OHPWs7dYe6tKB2vYTR0GOmbq/sZGxbxx29kDvm2K4zUK/dOwg/2WXdLuu2yrrFRXNEwYwYJZFuq5iTd2ZXqwDIwfavCNnoRWuwi1SreKJCYSMYext6TB21CNNmSIhORXMyxgrcywzLfahmDTM/NJMUtQ1zjXZvZmEQoMQehYNq0vEL41D98viYKJhGfIK0LEv7kXEZwBWXtjUFVGrKAHLgzcUckVC70Vu6LXtRBV8W5qFUDtGZkVBs/COKOedw5jVzbkfT20ltTkTgheA+9+F7r92lHeupyQVOOIOdTd13oqfuXDrB3u+LHracy46zocdk8V9IUjDrnHUX14A1sMu6XdZtlXWL3MraWUuN8EwZwDUA7sYs6UzbBMvDljkm2osSIOJAqr1QXZYdnzriNwzInsZG63ZQ15p80ye2xe+AapfmFi1tmEZDPrGueZLjQBPsK5OEtcVc05Bnp8rOHlD9Hm9S4GldZb7+MM8Oc96jJ4UrLMRLboa4iN1Ae5sSKtjHDePt5IXd3NdCe3exCzwH7LIO3W/6ZJd1Dos7TdM6yG3iquEQgEE0p6NVEDMCM1IuGsyompYSVt65LCoGW1/+iZJoA6KpZKVEdk2k6AeiQbHbzePcKGGNKPKTXtBqzGcqT9MG4jOuHhy5aFCJ3P5u2mchBQ6og6aZSrCuazNcgo3hQdIDaUA14yh9aaDvhfSjZw050Exf0ujCzoouCxOJWmrpuWTsPjIVBa5RHhRvnA9mU7MFL8/Ni+RC4oHJjismRt+G6LJJM+66ejidetap/a15uza/zZlut8JiasK2rVNugDnx3Pc2YZd18dku65aAeMV+u8MOO+ywww47FLj7w4Qddthhhx12eJ7AvmjusMMOO+yww0bYF80ddthhhx122Aj7ornDDjvssMMOG2FfNHfYYYcddthhI+yL5g477LDDDjtshP8fH21pcVKZD6YAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAChCAYAAAClBOSIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmP0lEQVR4nO2df7QkR3Xfv7dn3nur97Rv9QNkSSAWMCCDkSwUbCB20HJsY/PDRyFgGY4BC8k2yjn2MQlwHBNyLPmAjW0OCU6IxSHyGguOkHCMgwnEEIQkwBIGG1nBRooRAa92V0K7K+3v92am++aPqp7p7ukfVd3Vv2buB552flRXVVdXf++tW9U1xMwQBEEQBKEYr+0KCIIgCEJfEKMpCIIgCIaI0RQEQRAEQ8RoCoIgCIIhYjQFQRAEwRAxmoIgCIJgyNIYTSL6F0T0QM73TETPaKgujZUlCEJzENFT9f09zPj+HUT035quly1E9PNE9Nmc7/cQ0UNN1qkrLI3RZOYvMvPFbddDWF6I6MeI6K+I6CgRHSGiLxPRD7ddr2WHiNaI6CYi+i4RHSeie4noZXWUxcy/zcy/WCWPJgwWM3+UmV8aKbNzjn5bhnspjGaW1ycITUFEmwA+BeA/AzgHwJMA3ABgu816CQCAIYB9AK4AsAvAOwHcRkRPbbNSQr2UtQu9NZpEdDkRfV17hh8noluJ6F36uz1E9BAR/ToRPQxgr6FX8nIi+jYRHSKi3yciT+f3/UR0OxEd1t99lIjOitTlO0T0NiK6T48ibiWiHZHv305EB4noABFdkziPlxPRP+jz2E9Eb3PWSEKXeBYAMPMtzOwz82lm/iwz30dE1xPRR8KEyRAfEd1BRO/So9QTRPQXRHSu7ofHiOirIvDlYeaTzHw9M3+HmQNm/hSA/wfgn6WlJyKPiN6pR6bfI6I/IaJdiWTX6Pv9YPSeTrnWL9TX9XEi+jsi2hP57hwi2qvzeYyI/pyINgB8BsCFui+cIKILiehHiOhruj88QkTvy6j7nUT0av36R3U/e4V+/+NEdK9+fTURfUm/vksf/ne6vJ+L5PdW3QYHiehNWW2cdi6R716pR/eP67a4NPJdqrbmtINHRP+OiB7Uen0bEZ2j8wrvq2uJ6J8A3K7z+ohO+7i+l74v6zyAnhpNIloF8AkAfwzltd8C4FWJZOfr73YD+GXDrF8F4PkALgdwJYDQwBGA3wFwIYBnA7gIwPWJY68C8NMAngbgUgBX67r+NIC3AfhJAM8E8BOJ424C8GZm3gnguQBuN6yr0C/+LwCfiD5MRC8jorMtj38tgDdAjVC/H8DdAPZC9fFvAvhNl5VdZrRoPgvA32ckuVr/vQTA0wGcCeC/JNK8BOp+fymAXyei5H0PInoSgP8J4F1Q1/FtAP47ET1RJ7kZwDqAHwRwHoD/yMwnAbwMwAFmPlP/HQDwfgDvZ+ZNqP5xW0bd7wSwR7++AsC3Abw48v7O5AHMHH7/Q7q8W/X786FG5k8CcC2AD+T067lz0W3wPAB/BODNAM4F8EEAnySitcixc9qa0w6/CuBf6nO5EMBjAD6QqMsVUDr+UwB+QZ/DRbr86wCczjgHAD01mgBeCBVS+QNmHjPznwH460SaAMBvMvM2M+c2QoTfZeYjzPxPAP4TgNcBADN/i5k/p/N6FMD7oBo+yh8w8wFmPgLgLwBcpj+/CsBeZv6GvtDXJ44bA3gOEW0y82PM/LeGdRV6BDMfA/BjABjAhwA8SkSfLPJqI+xl5geZ+SiUh/0gM/9vZp4A+DiA59VS8SWDiFYAfBTAh5n5/oxkPw/gfcz8bWY+AeA3ALyW4uG+G/QI9v9AOTevS8nn9QA+zcyf1iPczwH4GlTE6wIoo3Cd1oUxM88ZtAhjAM8goicw8wlmvicj3Z2YadeLoQYD4ftUo1lQ5m/pun0awAkAc+tGCs7llwF8kJm/oiMwH4aasnhhJIssbU3jOgD/npkfYuZtKL19TeLaXK+vzWl9DucCeIYu/2/0vZpJX43mhQD2c3y3+X2JNI8y85ZlvtE8vqvLARF9HxF9TIdPjwH4CIAnJI59OPL6FJT3GdY1mW+UVwN4OYDv6tDJiyzrLPQEZv4mM1/NzE+GiipcCOWcmfBI5PXplPdnQqgEqemYmwGMAPxKTtILEb+PvwvlxEcdoFQtSbAbwM/qsODjRPQ4lGN1AdTI5wgzP2ZY/WuhRsf36xDjKzPS3Q3gWdpZuwzAnwC4iIieAOBHANyVcVwah7XTFhLVvSh557IbwFsTbXAR4u2Vpa1p7AbwiUhe3wTgI/va3AzgLwF8TIeOf087Tpn01WgeBPAkIqLIZxcl0pT5+ZZoHk8BcEC//m2d3yU6/PF6qJCtaV2T+c4qyfxVZr4SKmTx58gOqwgLhB7F/DGU8TwJFboKOb+NOi0zWktughLXVzPzOCf5AShxDnkKgAnijkyWlkTZB+BmZj4r8rfBzO/R351DkbUTEea0jZn/kZlfB6UjvwvgT/W8XzLdKQB/A+DXAHyDmUcA/grAv4WKXhzKOukK5J3LPgDvTrTBOjPfYpBvmsbvA/CyRH47mHl/2nF61HsDMz8HwD8H8EoAb8wrtK9G824o7+FXiGhIRFdCeUlVeTsRnU1EF0F1qjB2vxMq9HBUz0O83SLP2wBcTUTPIaJ1ROaeiGiV1PNQu/RNegwqrCwsGET0A3rRxJP1+4ugQnb3ALgXwIuJ6CmkFpT8Rns1XVr+EGqe62cMpnNuAfBviOhpRHQmlFN9a2LU9R+IaJ2IfhDAmzDTkigfAfAzRPRTRDTQi1L2ENGTmfkgVBj+v2pNWiGicG7xEQDnUmTxERG9noieyMwBgMf1x1lacifUSDoMkd6ReJ/GI1Dzt9YUnMuHAFxHRC8gxQYRvYKIdhpkPdcOAG4E8G4i2g0ARPREbR9SIaKXENElRDSA0t8xCjS4l0ZTe0f/Ciok8TjUyO9TqL58/39AeWH3Qk3Q36Q/vwFqcdBR/fmfWdT1M1AhuNsBfAvzC33eAOA7Oux7HdR8ibB4HAfwAgBfIaKTUMbyGwDequeybgVwH1T/+1RrtVxCtMC+GSpc+TDNVmNm3Yt/BBXWuwtqle0W1AKUKHdC3e+fB/BeZp7bKICZ90EtOHwHgEehRklvx0yX3wAl4vcD+B6At+jj7ocy3N/WYcgLoRbK/D0RnYBaFPTaHON/J9RA4K6M92lcD+DDuryrctJlkXUuXwPwS1ALqR6DarOrTTLMaIf3A/gkgM8S0XGo++wFOdmcD+BPoQzmN6Ha4ua8cokX5EeoiegrAG5k5r1t10UQBCENIvotAE9m5msKEwudpJcjTQAgoiuI6Hwdnv0FqKXI/6vtegmCIKSh502fAzU6FXpKn3fKuRhqvnAD6lmj1+jYuSAIQhf5W6gppLyVuULHWZjwrCAIgiDUTW/Ds4IgCILQNGI0BUEQBMGQ3DlNj2j+IdrIa5r+p4ASEeAw27xDw++KqhDLgxIv0wowKdyAubYKP0/kb7pLgnEZKfVPnkqZMgPmKlU15ie9n5U5A2HK54KP197vROsKMrYod9G1zmohkFG7piTKatCqZZnmFbuIGS3KFvnZMpcv575NP8Y077QvWb0USyQIZojWlWMZtG7pwrNpDS/GRBCERUO0rh6MRpp53lPW4ltbT6aKB2JLzBtLS+CgZ+VlMdeG1YtLzzBRkIw2BSEf0Tp7lk3rOjHSXEQhJ9R3I5RlEdtZEPrEIt6Dy6Z1jRrNrjVsE7R1zoR4Z7buRMt4sQTBEct4+yyL1hmFZ62GupHJ5ik5B9ueYJXQRlroJVwzx8gc6ecX6HDVWVr2rbGILrEgFCBal1OgaB0Ai5FmUyeX9BpcYdMubdoLV+fNiX8FQTBDtK4Z+qp1uSNNk+Hu3PMy4TEtXg0Xk8BZy7JZ/8f4glt4aiZ52oQgOOJOTvMWKyoIc4jWpX8uWjeP8XOadfUL16ucsi5GJ8IAOaT1t7J1dvFwryAsK6J19dJ3rbP7lZM8TyLxPrXyGa6DzYnmPXuUt0tEaxS4rpk7dZTIzu1BgrDEiNbZsyRaZ2w0u+69ANXay2ZXirqvSx/aWhAWlT7cf6J17ZFrNOcaLLL6qtTJ1nWlOf5yfhdJtzR6oUt4kn3siILQJqJ19lWprbCOa531j1BHVyp1IQ5dNiZeVIeqsXZBEPqNaJ2QhvsN2xNEh/hVOl/synL8ozopqnOlDpc8OO2EbE6yS/MbgtBjROvSv0dBGuODe6x1pXcEsn3INu1hW5t85jLsAB2qiiAINSFa16mqtI7VSNPl8L2OUIDLUEjRJPiid6Lk+S/6+QpCFNG67LIWDVuts57TjJUUpYWWLeooWR6fybGmaZxQYuI79ZCs+IlB/sl8F/1GEQRjROvcsQBa14lfOWkCF7tmhH+CIAhdRbSuXsqPNC1btLQn43DCN88bs6WtlWZGzVCirYoOkZV1wtIiWtcKXdW6pRlpCoIgCEJV8keaJTwfGw/HKG1HYgRdH2nlbblVS+aCsEiI1k3p+u3ettaVD8+mlJOseN5zP3X0D5M54SY6RBMPCzexxZUgCHFE69LLXSatyzeabcbWLT2/tE5rUp7NcVWbg3TGVX9KyMarrQLPvRCEBUW0bi5tFRZZ65yMNKtU3KWHYvvsUl22oG4Pr2mvVhAEhWidXblV6aLWGW3YbtMwRk4T6XQtPlHbRtHTfDMaySYMkRYeymt8lw9DC8KiIVpXU5kLqHVGq2fLNGyZ8EFbdGV0VnsHFgQhF9G6Zuiz1hmHZ/OGyVmE3oTxcS3O+E49zYI6mHgxqXMblPOdZf6CINSHaF08XYhoncLJnGYeqQ2RdaEqdCLbFeOUcmFtM6fod5hPQxmfm2LdiTLKKHt/dm3VmiB0GdE6y4qlFGtMi1pXaDSbtP4uli9XEXrb+YyszuuizWwn9ovSiwEUhHxE67LTitbNcD7SLPGM8By24ZFkmWRxsFFShzPp0fLSwhcmHSjsxLY3Xl/CH4LQB0TrzMtbJK2rPTxrQ96Jpl2vNoxA9AI2PXJrYw5ADK1DogpX9QE2odeI1uXTZa3LNZplKmrSuFkTxDbD6pgXY1BRSrwqWiYee6sFLtW7y8rIhRtaI64ePhYMSQ4JxIB2CtE6/Va0rpDWR5rJYbdJZ3IVR6/7GrvuS32bcxE0RTG0ou+TdzuRGNoeIlpnn18T2Gpd60bTlDoa0Xx5OBWm5xLdpU2DlKe5nHgthrNl0oykGM6FRbTOLa61rhNGs+Oje2sW7XyECtis1GgiH6FVFk0bFu18TLAzmmn3rUVrVZ3grjLqYWR4UBXPKTw+s14mcwIdQ+TZEXUbOpmYrg/RunlE6wBY7ghUtpAsyk6+1y7qTUwCCItNnsGkgt0rObAvSwynM0TrhDys957t40RvqdIqVlD64RJTxWCGacI/F2UKxojW2bNsWldqTpMBEMffh6S2v6PAt/0ybZqvG83eUTxxnFQ3j3Mc+vSTjJWf0w5tPJck1ICFwSQvPS0H0f3JvPDDqjUTSiBal13ismpdowuBXC2ftvku7HyUTBNJTLFn5lIyizy7VCUSJitRe0zWhS8xwpsay4yRJA0wNZJTA0pevuGU8GynEK1bXK0zMprTky97X5Y5LstTyRApyilofkKcpt6Z+j/FE4WfMYOZASIwGASCfjtbdp0oMvdUueoEf6yKTui719cIYZ+roiLaQKYazLQRZxCmD+KGE5BRZ42I1onWFeFkpGm6KMu0kraLsLLS53U51Zl0d6LZv+TpzkUEZgYHgeoA006lXhPI6HmlMucstEiVjQhClZk7JsVgepG+53nzefu+ytKfjTxzR52ykrYRROvM6uYiXVfpxHOaeShPB5hF7nNTF2SWln+kExHB87zpa2ZGwMrTYubpZ9N/QWBKemEJt9Hwwdq+dyQhg2QINs1g6n/VewICLVHM6k8bS/LIPFwr9A7Run7QSaOZDLWTi2aeC/TPOpHneSDPw8pwiOFwCM/zMBwO4Qc+tre3EQQBJuOJ6jxBMN+ZCkIlJh5kW3MA4TyI4ICcUWhy0Q8RAYOBMparK6CVFWA4BIYDwA+A06eByQQYE+D7YFbGNBauFXqPaF1zuNK62oxm6Uah+JvZZHZ2jtGYe+LwRNbzeYSeFhFhMBhgZTjE6uoqzlhfx3g8hu/7mEwmysv3edr5sjpTnZ0h69wo0RNsO0a0My3yBH4meaFNl89UpuRFRMpYrq2C11YRbOyAN5qAxmN1TfxA1UuHa1U2esQpo81O0Eete8t4jG94Hr66vj7VuhdtbeGHxmO81/NE63Lo5EhzjkhYIQu2msuh2D+e58EbDLBz506cfdZZuOTSS/HyV7wC+/btw969e3Ho0CEEvor3+8FMvKat7sB9WTpD1SWy+k7e4p3p6tbixTmpo0wAtDJUo81zdmF07gYefd46Bi89hCP7z8LFN61icPAI4AfgIFCi5UEtEOIg23DK3Ga/aUjrHtjYwIeOHMGNz38+nnbttaA77sBLb7oJ12xsYOD7onU5WDw9nQ6hoBEyvuTIX3EJGfF4T01mk57oJkL8D9G/ZABE/aumkwgDz8MZZ5yBzV27cPHFF+PKK6/Enj17sLm5ieFwCNKLNWKdOXpuiYaYnt+0Pime3/xh5kQaj0n/wUmfFiKoxRLebC4y/LPdfCCJF+Y5QLC+itHZqzj2TB+fuWwvrnrBX2N09hqwuqLLK1lOeCMITlgkrbv37LNxw7OfjV+7+2685r778OrbbsM7n/lMfGV9XbSugPpHmi7OLHSWIuEFT19Y1g/hBuQr5zoIjFZ6AazmiRCut2CMx2NsnT6NBx54AB+75Rbs378fx44dQ+D7M2+eY1lYnB/XM3/oKJ6anJOwmaNYGGIi4cVHiB6BBoN4Gubpwh0wFc81cjAztEGg3nMA2vYxPOVj8x/X8OK7r8Po4Aae9dhJYDyZLgKqdC5CM/RM6+7euROfffrT8ar3vAd3XXEFvvDII6J1BnQrPBtzbOJhhdBNIY8w8AaqI4UeBzMwiSyV5rABks2SWtT0uPF4jNOnT+OB++/HwYMHcerUKRw7ehS+7+uQSGSVWFktK39oJWLnm/Fd2CeTTuVSGM6EwYyhPXwMBqBh5JbhABgBoEA9GpKxSIcDjhngcI5IGVsGjcYYnJrg3H8Atg+sY+Wkj8Hh42ohEAfKwAqLRQe07rmHDmHP/v24+alPxSu//GU8d3MTXwjLEK3LxHrD9rTCy0DQw/nCctXkc3iWYTjf8wieN8BgZYggCDDCCBwE8JkR6KX6sdA/zXIEAGYCEWvPK4AfAKPtbZw8dQrj8Rjj8RjboxFG4xF830cQ6LQ5q8dSv2FnDlI2Bhchb0oiWb/o+6UwmEmiI8IkHgHeALS2qhbnkKf+HY1yDWdqMcwg3wdtjzA8tgVvNIQ3WsVgawKMxuCJDw4XAlmfgz5GRpzWLIPW/fDx4/j948fxlgsuwH2bm/j8BRfgDx96CG9aX8ftonW5FBrNOkXTuHGjrUCz0MXq6grWN86E7/s4hZPwfR8jAPB9BEGApA82lx0ziAA/CEDMOHHqJLa2t1VIhAgBBxhPJuCA4QfBfOdE/OLkeSpdMD55dUhro6WGAwCD2EekJ5Boxxp4cwOY+CDPA4/GasTo+WDfB0FvTBAxntPRJgdA4IE9gHxfPVB+9Bhw8hQ88jAYeGA/AG9vK4/f91UYLnxe02S1bLSTyoIgY5ZJ6549GuPqHTvwpRMn4J08ie9wgO+treLy7W18bjAQrcuh3fBsWm1jXlIkpIVwayeerh4bDIfY2NhQ4dMgwHg8xmQyQaBXGwLhMulIUdOrztPvw94RBAF8LXjTB361sZx1Io54YPF/e61PSz20BNJ285kauoDVylVmEDOwMsRkcwe8SQAvCNQq2MlEGUAARo+CBAyQXoHreSBMAPLAEwAcGslIaDYxepVnNXtGRa371a0tPLhxJu7Z2Jhq3Yu2t/E838d7PQ+2Wve+4QADImAymWrdHUS4YzhQ/V20LpNCo9mlOa2wUwRBAN/3sb6+jt27d2MymeDI4cPY2tqC7/s4vbUFnkzAPodu1rynx5jttRgEqpMGjIB8xJeGhR4cT+swzSD2eSzrzpMX9xdmcMBqG7tAGzHfR7DzDBx7+hnwJsAZh1YxOD3BykQvoGAGwwcCD+QFc3kBmH7O4Yp+Hs0MtudNDeW0r4UGMrmJe+QzfYCz815Guqx19+/ahQ8cOIB3X3opvrCxgUsOH8bvPfoo3ri2BmIWrcvBtdbZbdjeBNHx//QjBulJAdYz0zwd/alOMtQ7XFC4NRR0OI3VfELS/Zo5YdoLSzTn1PdLdCT1UShi/exEqaS0+9x3i07KaFN9ruc4pyFSDp13BEOCN9Bb4ZFnN4cYGjwdrgUQ28RAfRc3mEK9dFXr7tmxA79z2WV4x9e/jh847zy86uGHcc3mJr7o+6DxWLTOhopa14nVs7keXiRyEYYtgoBBYBw9egwPfutbGA6HWF1bhR8EGAwGGA6HevNhRgBEOgNi/87KYD3xHi7N1l5eND3zXBAlknXv6Gm16ydqOKMLgvQqVvZ9eIePYdcDA/DAQ3DGEBSw2v5udQXk+2rbu8hGBOrwiBBFXk/nOf3pB7PyUtJHPnR1xkKDVNG6TwyG2L1rF/71/v248bzzcI/nYbi1JVpXgOtqV97cwIbkEl+kvA8JnydSb6Kfz0IH49EYx48fx8mTJ/VjIcH04drpoo1EKRx7xbP/Mc/K5PhIlnm2gfb0PWd1Io5XmJB+4g2SVk1O/GV+0dMbxSWh0Zr2ie1tDI6cwOD4FmjCU0M73XDdYjMCDng+3CoGs/fUoXWXHDqEq44cwY3nPRFXHT6MHx1ti9YlaELrWh9pmmpyLGzB6uKPJxM1jxn4GK4MpztRDAcDTKLbZMyFLeIRjOk1DifMEe96XZrrsKVsvaPHLfVDC3q0yQGDiNXindEYfOo0KAgwWB3ORqbD4TRES6TDYIb7wxptjCD0mipa96Ltbdx4YoRf2rWJ+3buxJeGK/jgwwfxi2fuxOdF6wA0p3WVjKZtYWVOarY5cOTHUcEIOAAFPkZ6Y+vRaDSN64c/eTMts6AnhB0nXDGWljwri1l4vKAAWCzaKttzEwW46ESxfJcdDlRIazIBbW+rfrO1NvsR6YGn/gzzipG3JZ8YzNZpW+suDxhvXFvD3SDsHI3wxeEAb951Fi4fjXD7dMcgiNZZUkbrWh9pFqKv8nSqiWdXJQgCwJ8AYJw6dXq6dBqsOtp8Vhz7N1lM8nXRhTe6UIZXM1aWI1evz15jp4htf6dXx471YrMTp1THDB8R8YO5Y+dGkWlGUAyjkKN17/U8eGAMxqOp1t3hebhjbQ3BaDslK9G6uui+0QQi7hGmIQsAYFbzmEEQqAlz/fNeBB3uSpsOsmjavJQuL1CdA7msziSDxxzmnuombfw8AD4o3GfWVzv2EBGwom+l5OrXubxrNI7yCyf9R7SuUt5NaF0/jCaAsDk4FoPQzREwAgoQBmQJBD/Q+8Uypv/GhvKc3pjpYRjOTJP3WWaalNCCzYVNC6fEvqBEWoten5pUNFgRnd/0wv1mfd3G+jcHw9WzaYarToMphnKBEK3LKqsLWtcjoxlltlw6FKxAiwb5pEMbOmVkBdp8LooujLpcS15RfpmdUcgnfITEh1pMERpC8sDhL55E01XduWcaoqP0z4UFR7Suan6uta680dQLtuoahaR5QXFPQv9SROS5pKx0s9XcHPs8TnR6O38eIPpmWmbWpED0CnFGmhwoxVOzJq0OOUlFjhPkbHoQ/gg1eUHsuUz1NcfSGuVpUgcxmM0iWhev25JrXS9GmmEnmfOWmGO9J4xKUKQnmYYSisIXXcLkYieCOrnpBAPSDJWe6wQwne+MH1MQjg0NoeloUozlwiNaF6eLWlfeaDbcyqlTROF/tBtIeulZnhelFnTPf5M/aW68gDqjkuXJ0kmTDpCXRoylA9J2D7KdtywyhDK6bB/ROjOWROs6O9Isc6Im3oYgOCU6SrQxmNFRZWJ/z+l38luYS4FoXb+wM5oW8eI0alt8Eo3pZySZ6Y+eRM+Lm885W9knm9cM1pPvFdt3emgy2meZl9yMJUjOUeaNDIuMoe18p+Ae0brsonO+Wwata2yk2VSEw/riNUCTXqEE8VrENIRqkk7Csb1FtK65strAzmiWrGUbJ5e8eFZ1KFNhk2OKvKGqcwI5H2TdYLV5xILQZ0Trqh2zwFrn5FdOOPJnSt3i3AXxp8S/bcEZrwVBsEO0Lp1l0rrK4dn5lVmKtlZupuad9oidyXEuMSigqToVhVAcTTcIwkIhWmfIgmtdp1bPRitdthFZH5x5fMNWIDEnX5i2SvWyzjkZKaHEd2IYBaFZROv6q3W5RtNmUrfImhdV1sXJ5A3N2w4bmFKnEcvraGI4hWVGtK55+qp1lUeaLjpalbTJ4xhIbRWm+bRZpHmBLjxDU9Lyr/DIsXWZ8gyYIMwjWueePmpdrtF01WAmceNkWUUrn/LKijZEHQ2flueiGRkZeQrLhGhdOqJ183RqTjOKkQeQ0VtSj+Pct5U6Qq2dqMQdUcpTrNu9EwQhFdG6ROYd17rajGYy5m56Ql3S7OQkckjZ8IXruQcTr7av8x2C0BdE6+ZZZK2zNpqmjUgUScvlYseFZRmu0rI9tKieud8nvBjO+S6P5OovVzdY5jL5FO9UDKywzIjWidal4WRzg2jhVSeRKfLXFCZl2T7QHB5TpcyiPNggTZV8ATGcgpCGaN38MVXKLMqjS1rnLDw7VzG2q4g1ZdcOJ9wZ005kTJrXFRZd0oXK84RsJ+qLQklZ+XUplCQIbSJaF0+8bFpXONLM8qjynoNpBEcq7tKjilKlHbo0D1nG6xSEPiJaVy79smld4eYG0dd5nWiZwnjGcx2RtGVDFHnL08WYCYIbROvSEa2bxzg862KZsumJu5xTm7uQkVCFrSdVxisqCjUU5lEhzJFWh6LfnUurT5c6rCDUjWidaF0ejWxuYENdAl0UK7c917rapqiDiwETBPeI1mUjWhfH2d6zRflkfVY05DeavU09UKV1uYglL1Tj8gJH65zXTrbhkNhBgiBMEa1LzzajKGf0UesKw7NFncn1RG7YiFnx7LJLu5Msku3Iu0YuhGCZ5nCE5UW0rvt0Qes6uY1erOKuH8xxTNmiXF3grPLF0AlC9xGtM8+jK1rn1GjaVL4orcsJ8j6S9D5deFg2IY5S4RBBWBJE69zRN62rtBCoqrDWESPvR+HlqpDWmZbxJhME14jWdasKXdY6q5FmF2Ljy+yVuZhDEQShGNG6dumy1jmf06z6gGuI6bC6dONEnmFqi7S2SraH6zCpqccXziG4WlUoCGpn8y6YIzeI1llXYSG0zmrDdirI1OZ26MIF7Bpdemapq20k9JgeGUzRunrps9aVGmmmeQs2jbCsnahL7ZBHV280QWga0To3ZS+S1hntPVv4UK7BZ8nvTIbmJuWbDqnTGqfKhXQx3xDW3UXnjtUnJy5h+ry0rJ4VlgnROrP8ROsc/55mUcFpS4uTmH5Wla4YA9edyBVF4SlBWHZE6+xYFK2rtBAoaqFtPbS0NLaeQRFFYZSmO1PeJLjJMcZIfFUQnCJaZ8cia11rG7bbhjpclhmdm6hzaXNeXN/05krLRxAEt4jWmeeZxjJpXW3b6JXxNPLySH7O+gVVKaACrlbWlS6Y5z8qk01IHzqrIHQR0bqaC+6Y1lUymm3GyrsSp7ehzHNaYswEoX1E6+xYZK2zM5oWLlXZWLxVBykoJM97a4oqXmjVTpS3KqwvHVQQWkG0zppl0bpO/srJopC8gE12YDGKgiA0xTJpnb3RrGvNb5YbVqU8Vw8GlSjW5PtSVTM4SAymIDhAtM6oWJPvF0nr7J7TrKuGfctXEITFpm+aJFrXGM43N6hCHye8e0VGA2c9fC0IQj2I1tVMjVrX+pxmZuepGqqomkeNmKwsK6p6XtrMZ7Q62h6CsAyI1s3os9a1bjSbxsU+in0k7+HmrPtumdpHEBYN0bp5XGhd60az1o3BW3zWokyHTa1axlUucxo2u4Is000mCE0gWpd+zNzBHdc6Z3OanPjrKmIMsqHEv4IgzCNa13+qaJ27kWaV2LpBgNvIkTKsg+vOFPNqXM8xNDzfITeaIBQgWmdVB6vMy9Kg1tUSnrWpTEuPFznHxYbIbSK7BgmCPaJ1/aOq1jkzmlShN5hcAKPsXfXIkh4UY9YOtXeqkh5rFtMbgSJZLsIdLgiOEa1bbq3r9K+cNEHfvaYoLibkF8UbFoSmEK1rnja1LtdoulqynFU5Trww3QHfuC4FvZmzMrOYJzBu9DqsUVF+Weecd0itS/wEoZuI1pXKNvugBda6RnYEMm2/trw0Try2rYdRmzfYiZzYuy67zILQUUTrSmRaIb82tK715zTbItcbhH0oowsDszJ1SPMkKeNzQRD6h2jd/DFVtM7MaJaYLDZJWvv8mUnmnJ7UNHzSBbLCOS7q2bVzFYRaEa2zzrZJuqB1uUbTdkVSmWNl4Uk3kWsiLBOidcuL7TUxG2mmeChFHcVmyG+SzllIwPUDuU2RV+9k40QWG8zd4Dn5dCHsIgitIlrXPh3XOuOFQGXavW/XKqRvxoMif8nJ/b6diyC0jWhdd+mC1rnb3CDyusokc+1YLLF2kb2zc8+rt8055aStre6CsECI1qVnvyxaZzzS7FRncMCinQ8wfwMLgmDPomnDop0P0K7WWY00KcvFyjvGpoCqWMbwk3HwRexcRfR12kMQ6kS0bvFwpXWtb9i+yDTdDlXLk9V9gmCHaJ1imbTOzmjmbTtksarJCWkZlyjI9cXOys9FO2R6ihVcKJnHFIQUROtK57foWlduGz3HD/6WauCeDYl6Vl1BEADRuhL0rLrWNLL3bB6c+Nf22DL7JwqCIDSNaN1i4G5Os+TVjA7lXSzZLprsbmzhi8kDupHvKoUOig6WO00Q3CFaZ17QAmpdJzZsdxVrr7u92lh9ZlumbLQuCN1FtM5dmW1pnd2G7VE6oMhlLmaValtNcFd4QLcyFfLvwGUVhPYQrZuWJ1qXTutzmnVRl3fkIqRSdm7C5Ngq8yaCIPQP0bpmIWaRV0EQBEEwYWFHmoIgCILgGjGagiAIgmCIGE1BEARBMESMpiAIgiAYIkZTEARBEAwRoykIgiAIhvx/kIHUee60XeIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "batch = next(draw_generator)\n", + "blend_images = batch['blend_images']\n", + "blend_list = batch['blend_list']\n", + "btk.plot_utils.plot_blends(blend_images, blend_list, limits=(30,90))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.9" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "meta-shift-y" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "811.111px", + "left": "216px", + "top": "257.052px", + "width": "365.764px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/poetry.lock b/poetry.lock index 6b9e3038e..95417f067 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,3 +1,14 @@ +[[package]] +name = "absl-py" +version = "0.12.0" +description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py." +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +six = "*" + [[package]] name = "alabaster" version = "0.7.12" @@ -50,6 +61,14 @@ python-versions = ">=3.6.1" [package.dependencies] cached-property = "*" +[[package]] +name = "astor" +version = "0.8.1" +description = "Read/rewrite/write Python ASTs" +category = "main" +optional = true +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7" + [[package]] name = "astropy" version = "4.2" @@ -297,6 +316,7 @@ optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" [package.dependencies] +importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} mccabe = ">=0.6.0,<0.7.0" pycodestyle = ">=2.7.0,<2.8.0" pyflakes = ">=2.3.0,<2.4.0" @@ -335,16 +355,73 @@ future = "*" numpy = "*" pybind11 = ">=2.2" +[[package]] +name = "galsim-hub" +version = "0.0.1rc4" +description = "Support for Tensorflow Hub modules in GalSim" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +galsim = "*" +tensorflow_hub = "*" + +[[package]] +name = "gast" +version = "0.2.2" +description = "Python AST that abstracts the underlying Python version" +category = "main" +optional = true +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" + +[[package]] +name = "google-pasta" +version = "0.2.0" +description = "pasta is an AST-based Python refactoring library" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +six = "*" + +[[package]] +name = "grpcio" +version = "1.36.1" +description = "HTTP/2-based RPC framework" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +six = ">=1.5.2" + +[package.extras] +protobuf = ["grpcio-tools (>=1.36.1)"] + +[[package]] +name = "h5py" +version = "2.10.0" +description = "Read and write HDF5 files from Python" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +numpy = ">=1.7" +six = "*" + [[package]] name = "identify" -version = "2.1.3" +version = "2.2.2" description = "File identification library for Python" category = "dev" optional = false python-versions = ">=3.6.1" [package.extras] -license = ["editdistance"] +license = ["editdistance-s"] [[package]] name = "idna" @@ -381,6 +458,22 @@ category = "dev" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +[[package]] +name = "importlib-metadata" +version = "3.10.0" +description = "Read metadata from Python packages" +category = "main" +optional = false +python-versions = ">=3.6" + +[package.dependencies] +typing-extensions = {version = ">=3.6.4", markers = "python_version < \"3.8\""} +zipp = ">=0.5" + +[package.extras] +docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"] +testing = ["pytest (>=4.6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.0.1)", "packaging", "pep517", "pyfakefs", "flufl.flake8", "pytest-black (>=0.3.7)", "pytest-mypy", "importlib-resources (>=1.3)"] + [[package]] name = "iniconfig" version = "1.1.1" @@ -391,7 +484,7 @@ python-versions = "*" [[package]] name = "ipykernel" -version = "5.5.0" +version = "5.5.3" description = "IPython Kernel for Jupyter" category = "dev" optional = false @@ -409,7 +502,7 @@ test = ["pytest (!=5.3.4)", "pytest-cov", "flaky", "nose", "jedi (<=0.17.2)"] [[package]] name = "ipython" -version = "7.21.0" +version = "7.22.0" description = "IPython: Productive Interactive Computing" category = "dev" optional = false @@ -428,7 +521,7 @@ pygments = "*" traitlets = ">=4.2" [package.extras] -all = ["Sphinx (>=1.3)", "ipykernel", "ipyparallel", "ipywidgets", "nbconvert", "nbformat", "nose (>=0.10.1)", "notebook", "numpy (>=1.14)", "pygments", "qtconsole", "requests", "testpath"] +all = ["Sphinx (>=1.3)", "ipykernel", "ipyparallel", "ipywidgets", "nbconvert", "nbformat", "nose (>=0.10.1)", "notebook", "numpy (>=1.16)", "pygments", "qtconsole", "requests", "testpath"] doc = ["Sphinx (>=1.3)"] kernel = ["ipykernel"] nbconvert = ["nbconvert"] @@ -436,7 +529,7 @@ nbformat = ["nbformat"] notebook = ["notebook", "ipywidgets"] parallel = ["ipyparallel"] qtconsole = ["qtconsole"] -test = ["nose (>=0.10.1)", "requests", "testpath", "pygments", "nbformat", "ipykernel", "numpy (>=1.14)"] +test = ["nose (>=0.10.1)", "requests", "testpath", "pygments", "nbformat", "ipykernel", "numpy (>=1.16)"] [[package]] name = "ipython-genutils" @@ -504,6 +597,7 @@ python-versions = "*" [package.dependencies] attrs = ">=17.4.0" +importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} pyrsistent = ">=0.14.0" six = ">=1.11.0" @@ -576,6 +670,38 @@ category = "dev" optional = false python-versions = ">=3.6" +[[package]] +name = "keras-applications" +version = "1.0.8" +description = "Reference implementations of popular deep learning models" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +h5py = "*" +numpy = ">=1.9.1" + +[package.extras] +tests = ["pytest", "pytest-pep8", "pytest-xdist", "pytest-cov"] + +[[package]] +name = "keras-preprocessing" +version = "1.1.2" +description = "Easy data preprocessing and data augmentation for deep learning models" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +numpy = ">=1.9.1" +six = ">=1.9.0" + +[package.extras] +image = ["scipy (>=0.14)", "Pillow (>=5.2.0)"] +pep8 = ["flake8"] +tests = ["pandas", "pillow", "tensorflow", "keras", "pytest", "pytest-xdist", "pytest-cov"] + [[package]] name = "kiwisolver" version = "1.3.1" @@ -597,6 +723,20 @@ cffi = "*" future = "*" numpy = "*" +[[package]] +name = "markdown" +version = "3.3.4" +description = "Python implementation of Markdown." +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} + +[package.extras] +testing = ["coverage", "pyyaml"] + [[package]] name = "markupsafe" version = "1.1.1" @@ -607,19 +747,19 @@ python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" [[package]] name = "matplotlib" -version = "3.3.4" +version = "3.4.1" description = "Python plotting package" category = "main" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" [package.dependencies] cycler = ">=0.10" kiwisolver = ">=1.0.1" -numpy = ">=1.15" +numpy = ">=1.16" pillow = ">=6.2.0" -pyparsing = ">=2.0.3,<2.0.4 || >2.0.4,<2.1.2 || >2.1.2,<2.1.6 || >2.1.6" -python-dateutil = ">=2.1" +pyparsing = ">=2.2.1" +python-dateutil = ">=2.7" [[package]] name = "mccabe" @@ -771,11 +911,11 @@ python-versions = "*" [[package]] name = "notebook" -version = "6.2.0" +version = "6.3.0" description = "A web-based notebook environment for interactive computing" category = "dev" optional = false -python-versions = ">=3.5" +python-versions = ">=3.6" [package.dependencies] argon2-cffi = "*" @@ -800,11 +940,26 @@ test = ["pytest", "coverage", "requests", "nbval", "selenium", "pytest-cov", "re [[package]] name = "numpy" -version = "1.20.1" +version = "1.18.5" description = "NumPy is the fundamental package for array computing with Python." category = "main" optional = false -python-versions = ">=3.7" +python-versions = ">=3.5" + +[[package]] +name = "opt-einsum" +version = "3.3.0" +description = "Optimizing numpys einsum function" +category = "main" +optional = true +python-versions = ">=3.5" + +[package.dependencies] +numpy = ">=1.7" + +[package.extras] +docs = ["sphinx (==1.2.3)", "sphinxcontrib-napoleon", "sphinx-rtd-theme", "numpydoc"] +tests = ["pytest", "pytest-cov", "pytest-pep8"] [[package]] name = "packaging" @@ -827,7 +982,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" [[package]] name = "parso" -version = "0.8.1" +version = "0.8.2" description = "A Python Parser" category = "dev" optional = false @@ -880,6 +1035,9 @@ category = "dev" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +[package.dependencies] +importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""} + [package.extras] dev = ["pre-commit", "tox"] @@ -894,6 +1052,7 @@ python-versions = ">=3.6.1" [package.dependencies] cfgv = ">=2.0.0" identify = ">=1.0.0" +importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} nodeenv = ">=0.11.1" pyyaml = ">=5.1" toml = "*" @@ -912,7 +1071,7 @@ twisted = ["twisted"] [[package]] name = "prompt-toolkit" -version = "3.0.17" +version = "3.0.18" description = "Library for building powerful interactive command lines in Python" category = "dev" optional = false @@ -921,6 +1080,17 @@ python-versions = ">=3.6.1" [package.dependencies] wcwidth = "*" +[[package]] +name = "protobuf" +version = "3.15.6" +description = "Protocol Buffers" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +six = ">=1.9" + [[package]] name = "ptyprocess" version = "0.7.0" @@ -981,7 +1151,7 @@ test = ["pytest", "pytest-doctestplus (>=0.7)"] [[package]] name = "pyflakes" -version = "2.3.0" +version = "2.3.1" description = "passive checker of Python programs" category = "dev" optional = false @@ -1023,6 +1193,7 @@ python-versions = ">=3.6" atomicwrites = {version = ">=1.0", markers = "sys_platform == \"win32\""} attrs = ">=19.2.0" colorama = {version = "*", markers = "sys_platform == \"win32\""} +importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""} iniconfig = "*" packaging = "*" pluggy = ">=0.12,<1.0.0a1" @@ -1176,14 +1347,14 @@ test = ["pytest (>=5.2.0)", "pytest-cov (>=2.7.0)", "pytest-localserver", "pytes [[package]] name = "scipy" -version = "1.6.1" +version = "1.6.2" description = "SciPy: Scientific Library for Python" category = "main" optional = false -python-versions = ">=3.7" +python-versions = ">=3.7,<3.10" [package.dependencies] -numpy = ">=1.16.5" +numpy = ">=1.16.5,<1.23.0" [[package]] name = "send2trash" @@ -1222,7 +1393,7 @@ python-versions = "*" [[package]] name = "sphinx" -version = "3.5.2" +version = "3.5.3" description = "Python documentation generator" category = "dev" optional = false @@ -1333,9 +1504,84 @@ python-versions = ">=3.5" lint = ["flake8", "mypy", "docutils-stubs"] test = ["pytest"] +[[package]] +name = "tensorboard" +version = "1.15.0" +description = "TensorBoard lets you watch Tensors Flow" +category = "main" +optional = true +python-versions = ">= 2.7, != 3.0.*, != 3.1.*" + +[package.dependencies] +absl-py = ">=0.4" +grpcio = ">=1.6.3" +markdown = ">=2.6.8" +numpy = ">=1.12.0" +protobuf = ">=3.6.0" +six = ">=1.10.0" +werkzeug = ">=0.11.15" + +[[package]] +name = "tensorflow" +version = "1.15.5" +description = "TensorFlow is an open source machine learning framework for everyone." +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +absl-py = ">=0.7.0" +astor = ">=0.6.0" +gast = "0.2.2" +google-pasta = ">=0.1.6" +grpcio = ">=1.8.6" +h5py = "<=2.10.0" +keras-applications = ">=1.0.8" +keras-preprocessing = ">=1.0.5" +numpy = ">=1.16.0,<1.19.0" +opt-einsum = ">=2.3.2" +protobuf = ">=3.6.1" +six = ">=1.10.0" +tensorboard = ">=1.15.0,<1.16.0" +tensorflow-estimator = "1.15.1" +termcolor = ">=1.1.0" +wrapt = ">=1.11.1" + +[[package]] +name = "tensorflow-estimator" +version = "1.15.1" +description = "TensorFlow Estimator." +category = "main" +optional = true +python-versions = "*" + +[[package]] +name = "tensorflow-hub" +version = "0.11.0" +description = "TensorFlow Hub is a library to foster the publication, discovery, and consumption of reusable parts of machine learning models." +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +numpy = ">=1.12.0" +protobuf = ">=3.8.0" + +[package.extras] +make_image_classifier = ["keras-preprocessing"] +make_nearest_neighbour_index = ["apache-beam", "annoy"] + +[[package]] +name = "termcolor" +version = "1.1.0" +description = "ANSII Color formatting for output in terminal." +category = "main" +optional = true +python-versions = "*" + [[package]] name = "terminado" -version = "0.9.3" +version = "0.9.4" description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." category = "dev" optional = false @@ -1346,6 +1592,9 @@ ptyprocess = {version = "*", markers = "os_name != \"nt\""} pywinpty = {version = ">=0.5", markers = "os_name == \"nt\""} tornado = ">=4" +[package.extras] +test = ["pytest"] + [[package]] name = "testpath" version = "0.4.4" @@ -1413,7 +1662,7 @@ python-versions = "*" name = "typing-extensions" version = "3.7.4.3" description = "Backported and Experimental Type Hints for Python 3.5+" -category = "dev" +category = "main" optional = false python-versions = "*" @@ -1442,6 +1691,7 @@ python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7" appdirs = ">=1.4.3,<2" distlib = ">=0.3.1,<1" filelock = ">=3.0.0,<4" +importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""} six = ">=1.9.0,<2" [package.extras] @@ -1464,6 +1714,18 @@ category = "dev" optional = false python-versions = "*" +[[package]] +name = "werkzeug" +version = "1.0.1" +description = "The comprehensive WSGI web application library." +category = "main" +optional = true +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" + +[package.extras] +dev = ["pytest", "pytest-timeout", "coverage", "tox", "sphinx", "pallets-sphinx-themes", "sphinx-issues"] +watchdog = ["watchdog"] + [[package]] name = "widgetsnbextension" version = "3.5.1" @@ -1475,12 +1737,39 @@ python-versions = "*" [package.dependencies] notebook = ">=4.4.1" +[[package]] +name = "wrapt" +version = "1.12.1" +description = "Module for decorators, wrappers and monkey patching." +category = "main" +optional = true +python-versions = "*" + +[[package]] +name = "zipp" +version = "3.4.1" +description = "Backport of pathlib-compatible object wrapper for zip files" +category = "main" +optional = false +python-versions = ">=3.6" + +[package.extras] +docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"] +testing = ["pytest (>=4.6)", "pytest-checkdocs (>=1.2.3)", "pytest-flake8", "pytest-cov", "pytest-enabler", "jaraco.itertools", "func-timeout", "pytest-black (>=0.3.7)", "pytest-mypy"] + +[extras] +galsim-hub = ["galsim-hub"] + [metadata] lock-version = "1.1" -python-versions = "^3.8" -content-hash = "1b6b362c7e601df6f172f391df07f914e3c1c46f1121102c30f1cec595018e5e" +python-versions = "~3.7" +content-hash = "3a5e5d8b60137548ca2533789134dd702e2a9fae3ac5a385c9b59ac78c0b8dee" [metadata.files] +absl-py = [ + {file = "absl-py-0.12.0.tar.gz", hash = "sha256:b44f68984a5ceb2607d135a615999b93924c771238a63920d17d3387b0d229d5"}, + {file = "absl_py-0.12.0-py3-none-any.whl", hash = "sha256:afe94e3c751ff81aad55d33ab6e630390da32780110b5af72ae81ecff8418d9e"}, +] alabaster = [ {file = "alabaster-0.7.12-py2.py3-none-any.whl", hash = "sha256:446438bdcca0e05bd45ea2de1668c1d9b032e1a9154c2c259092d77031ddd359"}, {file = "alabaster-0.7.12.tar.gz", hash = "sha256:a661d72d58e6ea8a57f7a86e37d86716863ee5e92788398526d58b26a4e4dc02"}, @@ -1517,6 +1806,10 @@ argon2-cffi = [ {file = "aspy.refactor_imports-2.2.0-py2.py3-none-any.whl", hash = "sha256:7a18039d2e8be6b02b4791ce98891deb46b459b575c52ed35ab818c4eaa0c098"}, {file = "aspy.refactor_imports-2.2.0.tar.gz", hash = "sha256:78ca24122963fd258ebfc4a8dc708d23a18040ee39dca8767675821e84e9ea0a"}, ] +astor = [ + {file = "astor-0.8.1-py2.py3-none-any.whl", hash = "sha256:070a54e890cefb5b3739d19f30f5a5ec840ffc9c50ffa7d23cc9fc1a38ebbfc5"}, + {file = "astor-0.8.1.tar.gz", hash = "sha256:6a6effda93f4e1ce9f618779b2dd1d9d84f1e32812c23a29b3fff6fd7f63fa5e"}, +] astropy = [ {file = "astropy-4.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:882434f6fe29a2aba9fe61bddac13943c95a9d6e8fdb19f3e35a9f9ae039bd10"}, {file = "astropy-4.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:2fea9cf1fb1ef4e68e5c93c679a26dcc6313be55783fa1ee162eb72c8c9eb0b4"}, @@ -1754,9 +2047,99 @@ future = [ galsim = [ {file = "GalSim-2.2.5.tar.gz", hash = "sha256:a265d7af9862307890a3609ffad2a50717818884099b03612ae7b946683331c3"}, ] +galsim-hub = [ + {file = "galsim_hub-0.0.1rc4.tar.gz", hash = "sha256:45bcd5dbd987f2dfa9a0512a1c5f6c84ff42b7823a6b778b494ce984c13b0940"}, +] +gast = [ + {file = "gast-0.2.2.tar.gz", hash = "sha256:fe939df4583692f0512161ec1c880e0a10e71e6a232da045ab8edd3756fbadf0"}, +] +google-pasta = [ + {file = "google-pasta-0.2.0.tar.gz", hash = "sha256:c9f2c8dfc8f96d0d5808299920721be30c9eec37f2389f28904f454565c8a16e"}, + {file = "google_pasta-0.2.0-py2-none-any.whl", hash = "sha256:4612951da876b1a10fe3960d7226f0c7682cf901e16ac06e473b267a5afa8954"}, + {file = "google_pasta-0.2.0-py3-none-any.whl", hash = "sha256:b32482794a366b5366a32c92a9a9201b107821889935a02b3e51f6b432ea84ed"}, +] +grpcio = [ + {file = "grpcio-1.36.1-cp27-cp27m-macosx_10_10_x86_64.whl", hash = "sha256:e3a83c5db16f95daac1d96cf3c9018d765579b5a29bb336758d793028e729921"}, + {file = "grpcio-1.36.1-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:c18739fecb90760b183bfcb4da1cf2c6bf57e38f7baa2c131d5f67d9a4c8365d"}, + {file = "grpcio-1.36.1-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:f6efa62ca1fe02cd34ec35f53446f04a15fe2c886a4e825f5679936a573d2cbf"}, + {file = "grpcio-1.36.1-cp27-cp27m-win32.whl", hash = "sha256:9a18299827a70be0507f98a65393b1c7f6c004fe2ca995fe23ffac534dd187a7"}, + {file = "grpcio-1.36.1-cp27-cp27m-win_amd64.whl", hash = "sha256:8a89190de1985a54ef311650cf9687ffb81de038973fd32e452636ddae36b29f"}, + {file = "grpcio-1.36.1-cp27-cp27mu-linux_armv7l.whl", hash = "sha256:3e75643d21db7d68acd541d3fec66faaa8061d12b511e101b529ff12a276bb9b"}, + {file = "grpcio-1.36.1-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:3c5204e05e18268dd6a1099ca6c106fd9d00bcae1e37d5a5186094c55044c941"}, + {file = "grpcio-1.36.1-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:24d4c2c5e540e666c52225953d6813afc8ccf9bf46db6a72edd4e8d606656248"}, + {file = "grpcio-1.36.1-cp35-cp35m-linux_armv7l.whl", hash = "sha256:4dc7295dc9673f7af22c1e38c2a2c24ecbd6773a4c5ed5a46ed38ad4dcf2bf6c"}, + {file = "grpcio-1.36.1-cp35-cp35m-macosx_10_10_intel.whl", hash = "sha256:f241116d4bf1a8037ff87f16914b606390824e50902bdbfa2262e855fbf07fe5"}, + {file = "grpcio-1.36.1-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:1056b558acfd575d774644826df449e1402a03e456a3192fafb6b06d1069bf80"}, + {file = "grpcio-1.36.1-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:52ec563da45d06319224ebbda53501d25594de64ee1b2786e119ba4a2f1ce40c"}, + {file = "grpcio-1.36.1-cp35-cp35m-manylinux2014_i686.whl", hash = "sha256:7cbeac9bbe6a4a7fce4a89c892c249135dd9f5f5219ede157174c34a456188f0"}, + {file = "grpcio-1.36.1-cp35-cp35m-manylinux2014_x86_64.whl", hash = "sha256:2abaa9f0d83bd0b26f6d0d1fc4b97d73bde3ceac36ab857f70d3cabcf31c5c79"}, + {file = "grpcio-1.36.1-cp35-cp35m-win32.whl", hash = "sha256:02030e1afd3247f2b159df9dff959ec79dd4047b1c4dd4eec9e3d1642efbd504"}, + {file = "grpcio-1.36.1-cp35-cp35m-win_amd64.whl", hash = "sha256:eafafc7e040e36aa926edc731ab52c23465981888779ae64bfc8ad85888ed4f3"}, + {file = "grpcio-1.36.1-cp36-cp36m-linux_armv7l.whl", hash = "sha256:1030e74ddd0fa6e3bad7944f0c68cf1251b15bcd70641f0ad3858fdf2b8602a0"}, + {file = "grpcio-1.36.1-cp36-cp36m-macosx_10_10_x86_64.whl", hash = "sha256:b003e24339030ed356f59505d1065b89e1f443ef41ce71ca9069be944c0d2e6b"}, + {file = "grpcio-1.36.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:76daa3c4d58fcf40f7969bdb4270335e96ee0382a050cadcd97d7332cd0251a3"}, + {file = "grpcio-1.36.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:f591597bb25eae0094ead5a965555e911453e5f35fdbdaa83be11ef107865697"}, + {file = "grpcio-1.36.1-cp36-cp36m-manylinux2014_i686.whl", hash = "sha256:cbd82c479338fc1c0e5c3db09752b61fe47d40c6e38e4be8657153712fa76674"}, + {file = "grpcio-1.36.1-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:7e32bc01dfaa7a51c547379644ea619a2161d6969affdac3bbd173478d26673d"}, + {file = "grpcio-1.36.1-cp36-cp36m-win32.whl", hash = "sha256:5378189fb897567f4929f75ab67a3e0da4f8967806246cb9cfa1fa06bfbdb0d5"}, + {file = "grpcio-1.36.1-cp36-cp36m-win_amd64.whl", hash = "sha256:3a6295aa692806218e97bb687a71cd768450ed99e2acddc488f18d738edef463"}, + {file = "grpcio-1.36.1-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:6f6f8a8b57e40347d0bf32c2135037dae31d63d3b19007b4c426a11b76deaf65"}, + {file = "grpcio-1.36.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:4c05ed54b2a00df01e633bebec819b512bf0c60f8f5b3b36dd344dc673b02fea"}, + {file = "grpcio-1.36.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:e1b9e906aa6f7577016e86ed7f3a69cae7dab4e41356584dc7980f76ea65035f"}, + {file = "grpcio-1.36.1-cp37-cp37m-manylinux2014_i686.whl", hash = "sha256:a602d6b30760bbbb2fe776caaa914a0d404636cafc3f2322718bf8002d7b1e55"}, + {file = "grpcio-1.36.1-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:dee9971aef20fc09ed897420446c4d0926cd1d7630f343333288523ca5b44bb2"}, + {file = "grpcio-1.36.1-cp37-cp37m-win32.whl", hash = "sha256:ed16bfeda02268e75e038c58599d52afc7097d749916c079b26bc27a66900f7d"}, + {file = "grpcio-1.36.1-cp37-cp37m-win_amd64.whl", hash = "sha256:85a6035ae75ce964f78f19cf913938596ccf068b149fcd79f4371268bcb9aa7c"}, + {file = "grpcio-1.36.1-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:6b30682180053eebc87802c2f249d2f59b430e1a18e8808575dde0d22a968b2c"}, + {file = "grpcio-1.36.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:5e4920a8fb5d17b2c5ba980db0ac1c925bbee3e5d70e96da3ec4fb1c8600d68f"}, + {file = "grpcio-1.36.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:f7740d9d9451f3663df11b241ac05cafc0efaa052d2fdca6640c4d3748eaf6e2"}, + {file = "grpcio-1.36.1-cp38-cp38-manylinux2014_i686.whl", hash = "sha256:20b7c4c5513e1135a2261e56830c0e710f205fee92019b92fe132d7f16a5cfd8"}, + {file = "grpcio-1.36.1-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:216fbd2a488e74c3b96e240e4054c85c4c99102a439bc9f556936991643f43bc"}, + {file = "grpcio-1.36.1-cp38-cp38-win32.whl", hash = "sha256:7863c2a140e829b1f4c6d67bf0bf15e5321ac4766d0a295e2682970d9dd4b091"}, + {file = "grpcio-1.36.1-cp38-cp38-win_amd64.whl", hash = "sha256:f214076eb13da9e65c1aa9877b51fca03f51a82bd8691358e1a1edd9ff341330"}, + {file = "grpcio-1.36.1-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:ec753c022b39656f88409fbf9f2d3b28497e3f17aa678f884d78776b41ebe6bd"}, + {file = "grpcio-1.36.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:0648a6d5d7ddcd9c8462d7d961660ee024dad6b88152ee3a521819e611830edf"}, + {file = "grpcio-1.36.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:45ea10dd133a43b10c0b4326834107ebccfee25dab59b312b78e018c2d72a1f0"}, + {file = "grpcio-1.36.1-cp39-cp39-manylinux2014_i686.whl", hash = "sha256:bab743cdac1d6d8326c65d1d091d0740b39966dfab06519f74a03b3d128b8454"}, + {file = "grpcio-1.36.1-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:09af8ceb91860086216edc6e5ea15f9beb2cf81687faa43b7c03216f5b73e244"}, + {file = "grpcio-1.36.1-cp39-cp39-win32.whl", hash = "sha256:f3f70505207ee1cee65f60a799fd8e06e07861409aa0d55d834825a79b40c297"}, + {file = "grpcio-1.36.1-cp39-cp39-win_amd64.whl", hash = "sha256:f22c11772eff25ba1ca536e760b8c34ba56f2a9d66b6842cb11770a8f61f879d"}, + {file = "grpcio-1.36.1.tar.gz", hash = "sha256:a66ea59b20f3669df0f0c6a3bd57b985e5b2d1dcf3e4c29819bb8dc232d0fd38"}, +] +h5py = [ + {file = "h5py-2.10.0-cp27-cp27m-macosx_10_6_intel.whl", hash = "sha256:ecf4d0b56ee394a0984de15bceeb97cbe1fe485f1ac205121293fc44dcf3f31f"}, + {file = "h5py-2.10.0-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:86868dc07b9cc8cb7627372a2e6636cdc7a53b7e2854ad020c9e9d8a4d3fd0f5"}, + {file = "h5py-2.10.0-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:aac4b57097ac29089f179bbc2a6e14102dd210618e94d77ee4831c65f82f17c0"}, + {file = "h5py-2.10.0-cp27-cp27m-win32.whl", hash = "sha256:7be5754a159236e95bd196419485343e2b5875e806fe68919e087b6351f40a70"}, + {file = "h5py-2.10.0-cp27-cp27m-win_amd64.whl", hash = "sha256:13c87efa24768a5e24e360a40e0bc4c49bcb7ce1bb13a3a7f9902cec302ccd36"}, + {file = "h5py-2.10.0-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:79b23f47c6524d61f899254f5cd5e486e19868f1823298bc0c29d345c2447172"}, + {file = "h5py-2.10.0-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:cbf28ae4b5af0f05aa6e7551cee304f1d317dbed1eb7ac1d827cee2f1ef97a99"}, + {file = "h5py-2.10.0-cp34-cp34m-manylinux1_i686.whl", hash = "sha256:c0d4b04bbf96c47b6d360cd06939e72def512b20a18a8547fa4af810258355d5"}, + {file = "h5py-2.10.0-cp34-cp34m-manylinux1_x86_64.whl", hash = "sha256:549ad124df27c056b2e255ea1c44d30fb7a17d17676d03096ad5cd85edb32dc1"}, + {file = "h5py-2.10.0-cp35-cp35m-macosx_10_6_intel.whl", hash = "sha256:a5f82cd4938ff8761d9760af3274acf55afc3c91c649c50ab18fcff5510a14a5"}, + {file = "h5py-2.10.0-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:3dad1730b6470fad853ef56d755d06bb916ee68a3d8272b3bab0c1ddf83bb99e"}, + {file = "h5py-2.10.0-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:063947eaed5f271679ed4ffa36bb96f57bc14f44dd4336a827d9a02702e6ce6b"}, + {file = "h5py-2.10.0-cp35-cp35m-win32.whl", hash = "sha256:c54a2c0dd4957776ace7f95879d81582298c5daf89e77fb8bee7378f132951de"}, + {file = "h5py-2.10.0-cp35-cp35m-win_amd64.whl", hash = "sha256:6998be619c695910cb0effe5eb15d3a511d3d1a5d217d4bd0bebad1151ec2262"}, + {file = "h5py-2.10.0-cp36-cp36m-macosx_10_6_intel.whl", hash = "sha256:ff7d241f866b718e4584fa95f520cb19405220c501bd3a53ee11871ba5166ea2"}, + {file = "h5py-2.10.0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:54817b696e87eb9e403e42643305f142cd8b940fe9b3b490bbf98c3b8a894cf4"}, + {file = "h5py-2.10.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:d3c59549f90a891691991c17f8e58c8544060fdf3ccdea267100fa5f561ff62f"}, + {file = "h5py-2.10.0-cp36-cp36m-win32.whl", hash = "sha256:d7ae7a0576b06cb8e8a1c265a8bc4b73d05fdee6429bffc9a26a6eb531e79d72"}, + {file = "h5py-2.10.0-cp36-cp36m-win_amd64.whl", hash = "sha256:bffbc48331b4a801d2f4b7dac8a72609f0b10e6e516e5c480a3e3241e091c878"}, + {file = "h5py-2.10.0-cp37-cp37m-macosx_10_6_intel.whl", hash = "sha256:51ae56894c6c93159086ffa2c94b5b3388c0400548ab26555c143e7cfa05b8e5"}, + {file = "h5py-2.10.0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:16ead3c57141101e3296ebeed79c9c143c32bdd0e82a61a2fc67e8e6d493e9d1"}, + {file = "h5py-2.10.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:f0e25bb91e7a02efccb50aba6591d3fe2c725479e34769802fcdd4076abfa917"}, + {file = "h5py-2.10.0-cp37-cp37m-win32.whl", hash = "sha256:f23951a53d18398ef1344c186fb04b26163ca6ce449ebd23404b153fd111ded9"}, + {file = "h5py-2.10.0-cp37-cp37m-win_amd64.whl", hash = "sha256:8bb1d2de101f39743f91512a9750fb6c351c032e5cd3204b4487383e34da7f75"}, + {file = "h5py-2.10.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:64f74da4a1dd0d2042e7d04cf8294e04ddad686f8eba9bb79e517ae582f6668d"}, + {file = "h5py-2.10.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:d35f7a3a6cefec82bfdad2785e78359a0e6a5fbb3f605dd5623ce88082ccd681"}, + {file = "h5py-2.10.0-cp38-cp38-win32.whl", hash = "sha256:6ef7ab1089e3ef53ca099038f3c0a94d03e3560e6aff0e9d6c64c55fb13fc681"}, + {file = "h5py-2.10.0-cp38-cp38-win_amd64.whl", hash = "sha256:769e141512b54dee14ec76ed354fcacfc7d97fea5a7646b709f7400cf1838630"}, + {file = "h5py-2.10.0.tar.gz", hash = "sha256:84412798925dc870ffd7107f045d7659e60f5d46d1c70c700375248bf6bf512d"}, +] identify = [ - {file = "identify-2.1.3-py2.py3-none-any.whl", hash = "sha256:46d1816c6a4fc2d1e8758f293a5dcc1ae6404ab344179d7c1e73637bf283beb1"}, - {file = "identify-2.1.3.tar.gz", hash = "sha256:ed4a05fb80e3cbd12e83c959f9ff7f729ba6b66ab8d6178850fd5cb4c1cf6c5d"}, + {file = "identify-2.2.2-py2.py3-none-any.whl", hash = "sha256:c7c0f590526008911ccc5ceee6ed7b085cbc92f7b6591d0ee5913a130ad64034"}, + {file = "identify-2.2.2.tar.gz", hash = "sha256:43cb1965e84cdd247e875dec6d13332ef5be355ddc16776396d98089b9053d87"}, ] idna = [ {file = "idna-2.10-py2.py3-none-any.whl", hash = "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"}, @@ -1770,17 +2153,21 @@ imagesize = [ {file = "imagesize-1.2.0-py2.py3-none-any.whl", hash = "sha256:6965f19a6a2039c7d48bca7dba2473069ff854c36ae6f19d2cde309d998228a1"}, {file = "imagesize-1.2.0.tar.gz", hash = "sha256:b1f6b5a4eab1f73479a50fb79fcf729514a900c341d8503d62a62dbc4127a2b1"}, ] +importlib-metadata = [ + {file = "importlib_metadata-3.10.0-py3-none-any.whl", hash = "sha256:d2d46ef77ffc85cbf7dac7e81dd663fde71c45326131bea8033b9bad42268ebe"}, + {file = "importlib_metadata-3.10.0.tar.gz", hash = "sha256:c9db46394197244adf2f0b08ec5bc3cf16757e9590b02af1fca085c16c0d600a"}, +] iniconfig = [ {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"}, {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"}, ] ipykernel = [ - {file = "ipykernel-5.5.0-py3-none-any.whl", hash = "sha256:efd07253b54d84d26e0878d268c8c3a41582a18750da633c2febfd2ece0d467d"}, - {file = "ipykernel-5.5.0.tar.gz", hash = "sha256:98321abefdf0505fb3dc7601f60fc4087364d394bd8fad53107eb1adee9ff475"}, + {file = "ipykernel-5.5.3-py3-none-any.whl", hash = "sha256:21abd584543759e49010975a4621603b3cf871b1039cb3879a14094717692614"}, + {file = "ipykernel-5.5.3.tar.gz", hash = "sha256:a682e4f7affd86d9ce9b699d21bcab6d5ec9fbb2bfcb194f2706973b252bc509"}, ] ipython = [ - {file = "ipython-7.21.0-py3-none-any.whl", hash = "sha256:34207ffb2f653bced2bc8e3756c1db86e7d93e44ed049daae9814fed66d408ec"}, - {file = "ipython-7.21.0.tar.gz", hash = "sha256:04323f72d5b85b606330b6d7e2dc8d2683ad46c3905e955aa96ecc7a99388e70"}, + {file = "ipython-7.22.0-py3-none-any.whl", hash = "sha256:c0ce02dfaa5f854809ab7413c601c4543846d9da81010258ecdab299b542d199"}, + {file = "ipython-7.22.0.tar.gz", hash = "sha256:9c900332d4c5a6de534b4befeeb7de44ad0cc42e8327fa41b7685abde58cec74"}, ] ipython-genutils = [ {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"}, @@ -1822,6 +2209,14 @@ jupyterlab-widgets = [ {file = "jupyterlab_widgets-1.0.0-py3-none-any.whl", hash = "sha256:caeaf3e6103180e654e7d8d2b81b7d645e59e432487c1d35a41d6d3ee56b3fef"}, {file = "jupyterlab_widgets-1.0.0.tar.gz", hash = "sha256:5c1a29a84d3069208cb506b10609175b249b6486d6b1cbae8fcde2a11584fb78"}, ] +keras-applications = [ + {file = "Keras_Applications-1.0.8-py3-none-any.whl", hash = "sha256:df4323692b8c1174af821bf906f1e442e63fa7589bf0f1230a0b6bdc5a810c95"}, + {file = "Keras_Applications-1.0.8.tar.gz", hash = "sha256:5579f9a12bcde9748f4a12233925a59b93b73ae6947409ff34aa2ba258189fe5"}, +] +keras-preprocessing = [ + {file = "Keras_Preprocessing-1.1.2-py2.py3-none-any.whl", hash = "sha256:7b82029b130ff61cc99b55f3bd27427df4838576838c5b2f65940e4fcec99a7b"}, + {file = "Keras_Preprocessing-1.1.2.tar.gz", hash = "sha256:add82567c50c8bc648c14195bf544a5ce7c1f76761536956c3d2978970179ef3"}, +] kiwisolver = [ {file = "kiwisolver-1.3.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:fd34fbbfbc40628200730bc1febe30631347103fc8d3d4fa012c21ab9c11eca9"}, {file = "kiwisolver-1.3.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:d3155d828dec1d43283bd24d3d3e0d9c7c350cdfcc0bd06c0ad1209c1bbc36d0"}, @@ -1859,6 +2254,10 @@ kiwisolver = [ "lsstdesc.coord" = [ {file = "LSSTDESC.Coord-1.2.1.tar.gz", hash = "sha256:fbe8ed22222c69628def3685670b863339ce19fa5af6604e29d223cc0976d98a"}, ] +markdown = [ + {file = "Markdown-3.3.4-py3-none-any.whl", hash = "sha256:96c3ba1261de2f7547b46a00ea8463832c921d3f9d6aba3f255a6f71386db20c"}, + {file = "Markdown-3.3.4.tar.gz", hash = "sha256:31b5b491868dcc87d6c24b7e3d19a0d730d59d3e46f4eea6430a321bed387a49"}, +] markupsafe = [ {file = "MarkupSafe-1.1.1-cp27-cp27m-macosx_10_6_intel.whl", hash = "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161"}, {file = "MarkupSafe-1.1.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7"}, @@ -1914,31 +2313,25 @@ markupsafe = [ {file = "MarkupSafe-1.1.1.tar.gz", hash = "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b"}, ] matplotlib = [ - {file = "matplotlib-3.3.4-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:672960dd114e342b7c610bf32fb99d14227f29919894388b41553217457ba7ef"}, - {file = "matplotlib-3.3.4-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:7c155437ae4fd366e2700e2716564d1787700687443de46bcb895fe0f84b761d"}, - {file = "matplotlib-3.3.4-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:a17f0a10604fac7627ec82820439e7db611722e80c408a726cd00d8c974c2fb3"}, - {file = "matplotlib-3.3.4-cp36-cp36m-win32.whl", hash = "sha256:215e2a30a2090221a9481db58b770ce56b8ef46f13224ae33afe221b14b24dc1"}, - {file = "matplotlib-3.3.4-cp36-cp36m-win_amd64.whl", hash = "sha256:348e6032f666ffd151b323342f9278b16b95d4a75dfacae84a11d2829a7816ae"}, - {file = "matplotlib-3.3.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:94bdd1d55c20e764d8aea9d471d2ae7a7b2c84445e0fa463f02e20f9730783e1"}, - {file = "matplotlib-3.3.4-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:a1acb72f095f1d58ecc2538ed1b8bca0b57df313b13db36ed34b8cdf1868e674"}, - {file = "matplotlib-3.3.4-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:46b1a60a04e6d884f0250d5cc8dc7bd21a9a96c584a7acdaab44698a44710bab"}, - {file = "matplotlib-3.3.4-cp37-cp37m-win32.whl", hash = "sha256:ed4a9e6dcacba56b17a0a9ac22ae2c72a35b7f0ef0693aa68574f0b2df607a89"}, - {file = "matplotlib-3.3.4-cp37-cp37m-win_amd64.whl", hash = "sha256:c24c05f645aef776e8b8931cb81e0f1632d229b42b6d216e30836e2e145a2b40"}, - {file = "matplotlib-3.3.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7310e353a4a35477c7f032409966920197d7df3e757c7624fd842f3eeb307d3d"}, - {file = "matplotlib-3.3.4-cp38-cp38-manylinux1_i686.whl", hash = "sha256:451cc89cb33d6652c509fc6b588dc51c41d7246afdcc29b8624e256b7663ed1f"}, - {file = "matplotlib-3.3.4-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:3d2eb9c1cc254d0ffa90bc96fde4b6005d09c2228f99dfd493a4219c1af99644"}, - {file = "matplotlib-3.3.4-cp38-cp38-win32.whl", hash = "sha256:e15fa23d844d54e7b3b7243afd53b7567ee71c721f592deb0727ee85e668f96a"}, - {file = "matplotlib-3.3.4-cp38-cp38-win_amd64.whl", hash = "sha256:1de0bb6cbfe460725f0e97b88daa8643bcf9571c18ba90bb8e41432aaeca91d6"}, - {file = "matplotlib-3.3.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f44149a0ef5b4991aaef12a93b8e8d66d6412e762745fea1faa61d98524e0ba9"}, - {file = "matplotlib-3.3.4-cp39-cp39-manylinux1_i686.whl", hash = "sha256:746a1df55749629e26af7f977ea426817ca9370ad1569436608dc48d1069b87c"}, - {file = "matplotlib-3.3.4-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:5f571b92a536206f7958f7cb2d367ff6c9a1fa8229dc35020006e4cdd1ca0acd"}, - {file = "matplotlib-3.3.4-cp39-cp39-win32.whl", hash = "sha256:9265ae0fb35e29f9b8cc86c2ab0a2e3dcddc4dd9de4b85bf26c0f63fe5c1c2ca"}, - {file = "matplotlib-3.3.4-cp39-cp39-win_amd64.whl", hash = "sha256:9a79e5dd7bb797aa611048f5b70588b23c5be05b63eefd8a0d152ac77c4243db"}, - {file = "matplotlib-3.3.4-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:1e850163579a8936eede29fad41e202b25923a0a8d5ffd08ce50fc0a97dcdc93"}, - {file = "matplotlib-3.3.4-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:d738acfdfb65da34c91acbdb56abed46803db39af259b7f194dc96920360dbe4"}, - {file = "matplotlib-3.3.4-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:aa49571d8030ad0b9ac39708ee77bd2a22f87815e12bdee52ecaffece9313ed8"}, - {file = "matplotlib-3.3.4-pp37-pypy37_pp73-manylinux2010_x86_64.whl", hash = "sha256:cf3a7e54eff792f0815dbbe9b85df2f13d739289c93d346925554f71d484be78"}, - {file = "matplotlib-3.3.4.tar.gz", hash = "sha256:3e477db76c22929e4c6876c44f88d790aacdf3c3f8f3a90cb1975c0bf37825b0"}, + {file = "matplotlib-3.4.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7a54efd6fcad9cb3cd5ef2064b5a3eeb0b63c99f26c346bdcf66e7c98294d7cc"}, + {file = "matplotlib-3.4.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:86dc94e44403fa0f2b1dd76c9794d66a34e821361962fe7c4e078746362e3b14"}, + {file = "matplotlib-3.4.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:574306171b84cd6854c83dc87bc353cacc0f60184149fb00c9ea871eca8c1ecb"}, + {file = "matplotlib-3.4.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:84a10e462120aa7d9eb6186b50917ed5a6286ee61157bfc17c5b47987d1a9068"}, + {file = "matplotlib-3.4.1-cp37-cp37m-win32.whl", hash = "sha256:81e6fe8b18ef5be67f40a1d4f07d5a4ed21d3878530193898449ddef7793952f"}, + {file = "matplotlib-3.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:c45e7bf89ea33a2adaef34774df4e692c7436a18a48bcb0e47a53e698a39fa39"}, + {file = "matplotlib-3.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1f83a32e4b6045191f9d34e4dc68c0a17c870b57ef9cca518e516da591246e79"}, + {file = "matplotlib-3.4.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:a18cc1ab4a35b845cf33b7880c979f5c609fd26c2d6e74ddfacb73dcc60dd956"}, + {file = "matplotlib-3.4.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:ac2a30a09984c2719f112a574b6543ccb82d020fd1b23b4d55bf4759ba8dd8f5"}, + {file = "matplotlib-3.4.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:a97781453ac79409ddf455fccf344860719d95142f9c334f2a8f3fff049ffec3"}, + {file = "matplotlib-3.4.1-cp38-cp38-win32.whl", hash = "sha256:2eee37340ca1b353e0a43a33da79d0cd4bcb087064a0c3c3d1329cdea8fbc6f3"}, + {file = "matplotlib-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:90dbc007f6389bcfd9ef4fe5d4c78c8d2efe4e0ebefd48b4f221cdfed5672be2"}, + {file = "matplotlib-3.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7f16660edf9a8bcc0f766f51c9e1b9d2dc6ceff6bf636d2dbd8eb925d5832dfd"}, + {file = "matplotlib-3.4.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:a989022f89cda417f82dbf65e0a830832afd8af743d05d1414fb49549287ff04"}, + {file = "matplotlib-3.4.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:be4430b33b25e127fc4ea239cc386389de420be4d63e71d5359c20b562951ce1"}, + {file = "matplotlib-3.4.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:7561fd541477d41f3aa09457c434dd1f7604f3bd26d7858d52018f5dfe1c06d1"}, + {file = "matplotlib-3.4.1-cp39-cp39-win32.whl", hash = "sha256:9f374961a3996c2d1b41ba3145462c3708a89759e604112073ed6c8bdf9f622f"}, + {file = "matplotlib-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:53ceb12ef44f8982b45adc7a0889a7e2df1d758e8b360f460e435abe8a8cd658"}, + {file = "matplotlib-3.4.1.tar.gz", hash = "sha256:84d4c4f650f356678a5d658a43ca21a41fca13f9b8b00169c0b76e6a6a948908"}, ] mccabe = [ {file = "mccabe-0.6.1-py2.py3-none-any.whl", hash = "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42"}, @@ -1981,34 +2374,35 @@ nodeenv = [ {file = "nodeenv-1.5.0.tar.gz", hash = "sha256:ab45090ae383b716c4ef89e690c41ff8c2b257b85b309f01f3654df3d084bd7c"}, ] notebook = [ - {file = "notebook-6.2.0-py3-none-any.whl", hash = "sha256:25ad93c982b623441b491e693ef400598d1a46cdf11b8c9c0b3be6c61ebbb6cd"}, - {file = "notebook-6.2.0.tar.gz", hash = "sha256:0464b28e18e7a06cec37e6177546c2322739be07962dd13bf712bcb88361f013"}, + {file = "notebook-6.3.0-py3-none-any.whl", hash = "sha256:cb271af1e8134e3d6fc6d458bdc79c40cbfc84c1eb036a493f216d58f0880e92"}, + {file = "notebook-6.3.0.tar.gz", hash = "sha256:cbc9398d6c81473e9cdb891d2cae9c0d3718fca289dda6d26df5cb660fcadc7d"}, ] numpy = [ - {file = "numpy-1.20.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:ae61f02b84a0211abb56462a3b6cd1e7ec39d466d3160eb4e1da8bf6717cdbeb"}, - {file = "numpy-1.20.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:65410c7f4398a0047eea5cca9b74009ea61178efd78d1be9847fac1d6716ec1e"}, - {file = "numpy-1.20.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:2d7e27442599104ee08f4faed56bb87c55f8b10a5494ac2ead5c98a4b289e61f"}, - {file = "numpy-1.20.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:4ed8e96dc146e12c1c5cdd6fb9fd0757f2ba66048bf94c5126b7efebd12d0090"}, - {file = "numpy-1.20.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:ecb5b74c702358cdc21268ff4c37f7466357871f53a30e6f84c686952bef16a9"}, - {file = "numpy-1.20.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:b9410c0b6fed4a22554f072a86c361e417f0258838957b78bd063bde2c7f841f"}, - {file = "numpy-1.20.1-cp37-cp37m-win32.whl", hash = "sha256:3d3087e24e354c18fb35c454026af3ed8997cfd4997765266897c68d724e4845"}, - {file = "numpy-1.20.1-cp37-cp37m-win_amd64.whl", hash = "sha256:89f937b13b8dd17b0099c7c2e22066883c86ca1575a975f754babc8fbf8d69a9"}, - {file = "numpy-1.20.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a1d7995d1023335e67fb070b2fae6f5968f5be3802b15ad6d79d81ecaa014fe0"}, - {file = "numpy-1.20.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:60759ab15c94dd0e1ed88241fd4fa3312db4e91d2c8f5a2d4cf3863fad83d65b"}, - {file = "numpy-1.20.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:125a0e10ddd99a874fd357bfa1b636cd58deb78ba4a30b5ddb09f645c3512e04"}, - {file = "numpy-1.20.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:c26287dfc888cf1e65181f39ea75e11f42ffc4f4529e5bd19add57ad458996e2"}, - {file = "numpy-1.20.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:7199109fa46277be503393be9250b983f325880766f847885607d9b13848f257"}, - {file = "numpy-1.20.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:72251e43ac426ff98ea802a931922c79b8d7596480300eb9f1b1e45e0543571e"}, - {file = "numpy-1.20.1-cp38-cp38-win32.whl", hash = "sha256:c91ec9569facd4757ade0888371eced2ecf49e7982ce5634cc2cf4e7331a4b14"}, - {file = "numpy-1.20.1-cp38-cp38-win_amd64.whl", hash = "sha256:13adf545732bb23a796914fe5f891a12bd74cf3d2986eed7b7eba2941eea1590"}, - {file = "numpy-1.20.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:104f5e90b143dbf298361a99ac1af4cf59131218a045ebf4ee5990b83cff5fab"}, - {file = "numpy-1.20.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:89e5336f2bec0c726ac7e7cdae181b325a9c0ee24e604704ed830d241c5e47ff"}, - {file = "numpy-1.20.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:032be656d89bbf786d743fee11d01ef318b0781281241997558fa7950028dd29"}, - {file = "numpy-1.20.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:66b467adfcf628f66ea4ac6430ded0614f5cc06ba530d09571ea404789064adc"}, - {file = "numpy-1.20.1-cp39-cp39-win32.whl", hash = "sha256:12e4ba5c6420917571f1a5becc9338abbde71dd811ce40b37ba62dec7b39af6d"}, - {file = "numpy-1.20.1-cp39-cp39-win_amd64.whl", hash = "sha256:9c94cab5054bad82a70b2e77741271790304651d584e2cdfe2041488e753863b"}, - {file = "numpy-1.20.1-pp37-pypy37_pp73-manylinux2010_x86_64.whl", hash = "sha256:9eb551d122fadca7774b97db8a112b77231dcccda8e91a5bc99e79890797175e"}, - {file = "numpy-1.20.1.zip", hash = "sha256:3bc63486a870294683980d76ec1e3efc786295ae00128f9ea38e2c6e74d5a60a"}, + {file = "numpy-1.18.5-cp35-cp35m-macosx_10_9_intel.whl", hash = "sha256:e91d31b34fc7c2c8f756b4e902f901f856ae53a93399368d9a0dc7be17ed2ca0"}, + {file = "numpy-1.18.5-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:7d42ab8cedd175b5ebcb39b5208b25ba104842489ed59fbb29356f671ac93583"}, + {file = "numpy-1.18.5-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:a78e438db8ec26d5d9d0e584b27ef25c7afa5a182d1bf4d05e313d2d6d515271"}, + {file = "numpy-1.18.5-cp35-cp35m-win32.whl", hash = "sha256:a87f59508c2b7ceb8631c20630118cc546f1f815e034193dc72390db038a5cb3"}, + {file = "numpy-1.18.5-cp35-cp35m-win_amd64.whl", hash = "sha256:965df25449305092b23d5145b9bdaeb0149b6e41a77a7d728b1644b3c99277c1"}, + {file = "numpy-1.18.5-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:ac792b385d81151bae2a5a8adb2b88261ceb4976dbfaaad9ce3a200e036753dc"}, + {file = "numpy-1.18.5-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:ef627986941b5edd1ed74ba89ca43196ed197f1a206a3f18cc9faf2fb84fd675"}, + {file = "numpy-1.18.5-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:f718a7949d1c4f622ff548c572e0c03440b49b9531ff00e4ed5738b459f011e8"}, + {file = "numpy-1.18.5-cp36-cp36m-win32.whl", hash = "sha256:4064f53d4cce69e9ac613256dc2162e56f20a4e2d2086b1956dd2fcf77b7fac5"}, + {file = "numpy-1.18.5-cp36-cp36m-win_amd64.whl", hash = "sha256:b03b2c0badeb606d1232e5f78852c102c0a7989d3a534b3129e7856a52f3d161"}, + {file = "numpy-1.18.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a7acefddf994af1aeba05bbbafe4ba983a187079f125146dc5859e6d817df824"}, + {file = "numpy-1.18.5-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:cd49930af1d1e49a812d987c2620ee63965b619257bd76eaaa95870ca08837cf"}, + {file = "numpy-1.18.5-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:b39321f1a74d1f9183bf1638a745b4fd6fe80efbb1f6b32b932a588b4bc7695f"}, + {file = "numpy-1.18.5-cp37-cp37m-win32.whl", hash = "sha256:cae14a01a159b1ed91a324722d746523ec757357260c6804d11d6147a9e53e3f"}, + {file = "numpy-1.18.5-cp37-cp37m-win_amd64.whl", hash = "sha256:0172304e7d8d40e9e49553901903dc5f5a49a703363ed756796f5808a06fc233"}, + {file = "numpy-1.18.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e15b382603c58f24265c9c931c9a45eebf44fe2e6b4eaedbb0d025ab3255228b"}, + {file = "numpy-1.18.5-cp38-cp38-manylinux1_i686.whl", hash = "sha256:3676abe3d621fc467c4c1469ee11e395c82b2d6b5463a9454e37fe9da07cd0d7"}, + {file = "numpy-1.18.5-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:4674f7d27a6c1c52a4d1aa5f0881f1eff840d2206989bae6acb1c7668c02ebfb"}, + {file = "numpy-1.18.5-cp38-cp38-win32.whl", hash = "sha256:9c9d6531bc1886454f44aa8f809268bc481295cf9740827254f53c30104f074a"}, + {file = "numpy-1.18.5-cp38-cp38-win_amd64.whl", hash = "sha256:3dd6823d3e04b5f223e3e265b4a1eae15f104f4366edd409e5a5e413a98f911f"}, + {file = "numpy-1.18.5.zip", hash = "sha256:34e96e9dae65c4839bd80012023aadd6ee2ccb73ce7fdf3074c62f301e63120b"}, +] +opt-einsum = [ + {file = "opt_einsum-3.3.0-py3-none-any.whl", hash = "sha256:2455e59e3947d3c275477df7f5205b30635e266fe6dc300e3d9f9646bfcea147"}, + {file = "opt_einsum-3.3.0.tar.gz", hash = "sha256:59f6475f77bbc37dcf7cd748519c0ec60722e91e63ca114e68821c0c54a46549"}, ] packaging = [ {file = "packaging-20.9-py2.py3-none-any.whl", hash = "sha256:67714da7f7bc052e064859c05c595155bd1ee9f69f76557e21f051443c20947a"}, @@ -2018,8 +2412,8 @@ pandocfilters = [ {file = "pandocfilters-1.4.3.tar.gz", hash = "sha256:bc63fbb50534b4b1f8ebe1860889289e8af94a23bff7445259592df25a3906eb"}, ] parso = [ - {file = "parso-0.8.1-py2.py3-none-any.whl", hash = "sha256:15b00182f472319383252c18d5913b69269590616c947747bc50bf4ac768f410"}, - {file = "parso-0.8.1.tar.gz", hash = "sha256:8519430ad07087d4c997fda3a7918f7cfa27cb58972a8c89c2a0295a1c940e9e"}, + {file = "parso-0.8.2-py2.py3-none-any.whl", hash = "sha256:a8c4922db71e4fdb90e0d0bc6e50f9b273d3397925e5e60a717e719201778d22"}, + {file = "parso-0.8.2.tar.gz", hash = "sha256:12b83492c6239ce32ff5eed6d3639d6a536170723c6f3f1506869f1ace413398"}, ] pathspec = [ {file = "pathspec-0.8.1-py2.py3-none-any.whl", hash = "sha256:aa0cb481c4041bf52ffa7b0d8fa6cd3e88a2ca4879c533c9153882ee2556790d"}, @@ -2081,8 +2475,30 @@ prometheus-client = [ {file = "prometheus_client-0.9.0.tar.gz", hash = "sha256:9da7b32f02439d8c04f7777021c304ed51d9ec180604700c1ba72a4d44dceb03"}, ] prompt-toolkit = [ - {file = "prompt_toolkit-3.0.17-py3-none-any.whl", hash = "sha256:4cea7d09e46723885cb8bc54678175453e5071e9449821dce6f017b1d1fbfc1a"}, - {file = "prompt_toolkit-3.0.17.tar.gz", hash = "sha256:9397a7162cf45449147ad6042fa37983a081b8a73363a5253dd4072666333137"}, + {file = "prompt_toolkit-3.0.18-py3-none-any.whl", hash = "sha256:bf00f22079f5fadc949f42ae8ff7f05702826a97059ffcc6281036ad40ac6f04"}, + {file = "prompt_toolkit-3.0.18.tar.gz", hash = "sha256:e1b4f11b9336a28fa11810bc623c357420f69dfdb6d2dac41ca2c21a55c033bc"}, +] +protobuf = [ + {file = "protobuf-3.15.6-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:1771ef20e88759c4d81db213e89b7a1fc53937968e12af6603c658ee4bcbfa38"}, + {file = "protobuf-3.15.6-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:1a66261a402d05c8ad8c1fde8631837307bf8d7e7740a4f3941fc3277c2e1528"}, + {file = "protobuf-3.15.6-cp35-cp35m-macosx_10_9_intel.whl", hash = "sha256:eac23a3e56175b710f3da9a9e8e2aa571891fbec60e0c5a06db1c7b1613b5cfd"}, + {file = "protobuf-3.15.6-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:9ec220d90eda8bb7a7a1434a8aed4fe26d7e648c1a051c2885f3f5725b6aa71a"}, + {file = "protobuf-3.15.6-cp35-cp35m-win32.whl", hash = "sha256:88d8f21d1ac205eedb6dea943f8204ed08201b081dba2a966ab5612788b9bb1e"}, + {file = "protobuf-3.15.6-cp35-cp35m-win_amd64.whl", hash = "sha256:eaada29bbf087dea7d8bce4d1d604fc768749e8809e9c295922accd7c8fce4d5"}, + {file = "protobuf-3.15.6-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:256c0b2e338c1f3228d3280707606fe5531fde85ab9d704cde6fdeb55112531f"}, + {file = "protobuf-3.15.6-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:b9069e45b6e78412fba4a314ea38b4a478686060acf470d2b131b3a2c50484ec"}, + {file = "protobuf-3.15.6-cp36-cp36m-win32.whl", hash = "sha256:24f4697f57b8520c897a401b7f9a5ae45c369e22c572e305dfaf8053ecb49687"}, + {file = "protobuf-3.15.6-cp36-cp36m-win_amd64.whl", hash = "sha256:d9ed0955b794f1e5f367e27f8a8ff25501eabe34573f003f06639c366ca75f73"}, + {file = "protobuf-3.15.6-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:822ac7f87fc2fb9b24edd2db390538b60ef50256e421ca30d65250fad5a3d477"}, + {file = "protobuf-3.15.6-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:74ac159989e2b02d761188a2b6f4601ff5e494d9b9d863f5ad6e98e5e0c54328"}, + {file = "protobuf-3.15.6-cp37-cp37m-win32.whl", hash = "sha256:30fe4249a364576f9594180589c3f9c4771952014b5f77f0372923fc7bafbbe2"}, + {file = "protobuf-3.15.6-cp37-cp37m-win_amd64.whl", hash = "sha256:45a91fc6f9aa86d3effdeda6751882b02de628519ba06d7160daffde0c889ff8"}, + {file = "protobuf-3.15.6-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:83c7c7534f050cb25383bb817159416601d1cc46c40bc5e851ec8bbddfc34a2f"}, + {file = "protobuf-3.15.6-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:9ec20a6ded7d0888e767ad029dbb126e604e18db744ac0a428cf746e040ccecd"}, + {file = "protobuf-3.15.6-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0f2da2fcc4102b6c3b57f03c9d8d5e37c63f8bc74deaa6cb54e0cc4524a77247"}, + {file = "protobuf-3.15.6-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:70054ae1ce5dea7dec7357db931fcf487f40ea45b02cb719ee6af07eb1e906fb"}, + {file = "protobuf-3.15.6-py2.py3-none-any.whl", hash = "sha256:1655fc0ba7402560d749de13edbfca1ac45d1753d8f4e5292989f18f5a00c215"}, + {file = "protobuf-3.15.6.tar.gz", hash = "sha256:2b974519a2ae83aa1e31cff9018c70bbe0e303a46a598f982943c49ae1d4fcd3"}, ] ptyprocess = [ {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, @@ -2136,8 +2552,8 @@ pyerfa = [ {file = "pyerfa-1.7.2.tar.gz", hash = "sha256:31776213ec36e6bb5382b526be02e417b8697d791c6837199342c19e7dabe8e8"}, ] pyflakes = [ - {file = "pyflakes-2.3.0-py2.py3-none-any.whl", hash = "sha256:910208209dcea632721cb58363d0f72913d9e8cf64dc6f8ae2e02a3609aba40d"}, - {file = "pyflakes-2.3.0.tar.gz", hash = "sha256:e59fd8e750e588358f1b8885e5a4751203a0516e0ee6d34811089ac294c8806f"}, + {file = "pyflakes-2.3.1-py2.py3-none-any.whl", hash = "sha256:7893783d01b8a89811dd72d7dfd4d84ff098e5eed95cfa8905b22bbffe52efc3"}, + {file = "pyflakes-2.3.1.tar.gz", hash = "sha256:f5bc8ecabc05bb9d291eb5203d6810b49040f6ff446a756326104746cc00c1db"}, ] pygments = [ {file = "Pygments-2.8.1-py3-none-any.whl", hash = "sha256:534ef71d539ae97d4c3a4cf7d6f110f214b0e687e92f9cb9d2a3b0d3101289c8"}, @@ -2357,25 +2773,25 @@ scikit-image = [ {file = "scikit_image-0.18.1-cp39-cp39-win_amd64.whl", hash = "sha256:5f602779258807d03e72c0a439cfb221f647e628be166fb3594397435f13c76b"}, ] scipy = [ - {file = "scipy-1.6.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a15a1f3fc0abff33e792d6049161b7795909b40b97c6cc2934ed54384017ab76"}, - {file = "scipy-1.6.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:e79570979ccdc3d165456dd62041d9556fb9733b86b4b6d818af7a0afc15f092"}, - {file = "scipy-1.6.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:a423533c55fec61456dedee7b6ee7dce0bb6bfa395424ea374d25afa262be261"}, - {file = "scipy-1.6.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:33d6b7df40d197bdd3049d64e8e680227151673465e5d85723b3b8f6b15a6ced"}, - {file = "scipy-1.6.1-cp37-cp37m-win32.whl", hash = "sha256:6725e3fbb47da428794f243864f2297462e9ee448297c93ed1dcbc44335feb78"}, - {file = "scipy-1.6.1-cp37-cp37m-win_amd64.whl", hash = "sha256:5fa9c6530b1661f1370bcd332a1e62ca7881785cc0f80c0d559b636567fab63c"}, - {file = "scipy-1.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bd50daf727f7c195e26f27467c85ce653d41df4358a25b32434a50d8870fc519"}, - {file = "scipy-1.6.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:f46dd15335e8a320b0fb4685f58b7471702234cba8bb3442b69a3e1dc329c345"}, - {file = "scipy-1.6.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:0e5b0ccf63155d90da576edd2768b66fb276446c371b73841e3503be1d63fb5d"}, - {file = "scipy-1.6.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:2481efbb3740977e3c831edfd0bd9867be26387cacf24eb5e366a6a374d3d00d"}, - {file = "scipy-1.6.1-cp38-cp38-win32.whl", hash = "sha256:68cb4c424112cd4be886b4d979c5497fba190714085f46b8ae67a5e4416c32b4"}, - {file = "scipy-1.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:5f331eeed0297232d2e6eea51b54e8278ed8bb10b099f69c44e2558c090d06bf"}, - {file = "scipy-1.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0c8a51d33556bf70367452d4d601d1742c0e806cd0194785914daf19775f0e67"}, - {file = "scipy-1.6.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:83bf7c16245c15bc58ee76c5418e46ea1811edcc2e2b03041b804e46084ab627"}, - {file = "scipy-1.6.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:794e768cc5f779736593046c9714e0f3a5940bc6dcc1dba885ad64cbfb28e9f0"}, - {file = "scipy-1.6.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:5da5471aed911fe7e52b86bf9ea32fb55ae93e2f0fac66c32e58897cfb02fa07"}, - {file = "scipy-1.6.1-cp39-cp39-win32.whl", hash = "sha256:8e403a337749ed40af60e537cc4d4c03febddcc56cd26e774c9b1b600a70d3e4"}, - {file = "scipy-1.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:a5193a098ae9f29af283dcf0041f762601faf2e595c0db1da929875b7570353f"}, - {file = "scipy-1.6.1.tar.gz", hash = "sha256:c4fceb864890b6168e79b0e714c585dbe2fd4222768ee90bc1aa0f8218691b11"}, + {file = "scipy-1.6.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:77f7a057724545b7e097bfdca5c6006bed8580768cd6621bb1330aedf49afba5"}, + {file = "scipy-1.6.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:e547f84cd52343ac2d56df0ab08d3e9cc202338e7d09fafe286d6c069ddacb31"}, + {file = "scipy-1.6.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:bc52d4d70863141bb7e2f8fd4d98e41d77375606cde50af65f1243ce2d7853e8"}, + {file = "scipy-1.6.2-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:adf7cee8e5c92b05f2252af498f77c7214a2296d009fc5478fc432c2f8fb953b"}, + {file = "scipy-1.6.2-cp37-cp37m-win32.whl", hash = "sha256:e3e9742bad925c421d39e699daa8d396c57535582cba90017d17f926b61c1552"}, + {file = "scipy-1.6.2-cp37-cp37m-win_amd64.whl", hash = "sha256:ffdfb09315896c6e9ac739bb6e13a19255b698c24e6b28314426fd40a1180822"}, + {file = "scipy-1.6.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6ca1058cb5bd45388041a7c3c11c4b2bd58867ac9db71db912501df77be2c4a4"}, + {file = "scipy-1.6.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:993c86513272bc84c451349b10ee4376652ab21f312b0554fdee831d593b6c02"}, + {file = "scipy-1.6.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:37f4c2fb904c0ba54163e03993ce3544c9c5cde104bcf90614f17d85bdfbb431"}, + {file = "scipy-1.6.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:96620240b393d155097618bcd6935d7578e85959e55e3105490bbbf2f594c7ad"}, + {file = "scipy-1.6.2-cp38-cp38-win32.whl", hash = "sha256:03f1fd3574d544456325dae502facdf5c9f81cbfe12808a5e67a737613b7ba8c"}, + {file = "scipy-1.6.2-cp38-cp38-win_amd64.whl", hash = "sha256:0c81ea1a95b4c9e0a8424cf9484b7b8fa7ef57169d7bcc0dfcfc23e3d7c81a12"}, + {file = "scipy-1.6.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c1d3f771c19af00e1a36f749bd0a0690cc64632783383bc68f77587358feb5a4"}, + {file = "scipy-1.6.2-cp39-cp39-manylinux1_i686.whl", hash = "sha256:50e5bcd9d45262725e652611bb104ac0919fd25ecb78c22f5282afabd0b2e189"}, + {file = "scipy-1.6.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:816951e73d253a41fa2fd5f956f8e8d9ac94148a9a2039e7db56994520582bf2"}, + {file = "scipy-1.6.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:1fba8a214c89b995e3721670e66f7053da82e7e5d0fe6b31d8e4b19922a9315e"}, + {file = "scipy-1.6.2-cp39-cp39-win32.whl", hash = "sha256:e89091e6a8e211269e23f049473b2fde0c0e5ae0dd5bd276c3fc91b97da83480"}, + {file = "scipy-1.6.2-cp39-cp39-win_amd64.whl", hash = "sha256:d744657c27c128e357de2f0fd532c09c84cd6e4933e8232895a872e67059ac37"}, + {file = "scipy-1.6.2.tar.gz", hash = "sha256:e9da33e21c9bc1b92c20b5328adb13e5f193b924c9b969cd700c8908f315aa59"}, ] send2trash = [ {file = "Send2Trash-1.5.0-py3-none-any.whl", hash = "sha256:f1691922577b6fa12821234aeb57599d887c4900b9ca537948d2dac34aea888b"}, @@ -2423,8 +2839,8 @@ snowballstemmer = [ {file = "snowballstemmer-2.1.0.tar.gz", hash = "sha256:e997baa4f2e9139951b6f4c631bad912dfd3c792467e2f03d7239464af90e914"}, ] sphinx = [ - {file = "Sphinx-3.5.2-py3-none-any.whl", hash = "sha256:ef64a814576f46ec7de06adf11b433a0d6049be007fefe7fd0d183d28b581fac"}, - {file = "Sphinx-3.5.2.tar.gz", hash = "sha256:672cfcc24b6b69235c97c750cb190a44ecd72696b4452acaf75c2d9cc78ca5ff"}, + {file = "Sphinx-3.5.3-py3-none-any.whl", hash = "sha256:3f01732296465648da43dec8fb40dc451ba79eb3e2cc5c6d79005fd98197107d"}, + {file = "Sphinx-3.5.3.tar.gz", hash = "sha256:ce9c228456131bab09a3d7d10ae58474de562a6f79abb3dc811ae401cf8c1abc"}, ] sphinx-rtd-theme = [ {file = "sphinx_rtd_theme-0.4.3-py2.py3-none-any.whl", hash = "sha256:00cf895504a7895ee433807c62094cf1e95f065843bf3acd17037c3e9a2becd4"}, @@ -2454,9 +2870,30 @@ sphinxcontrib-serializinghtml = [ {file = "sphinxcontrib-serializinghtml-1.1.4.tar.gz", hash = "sha256:eaa0eccc86e982a9b939b2b82d12cc5d013385ba5eadcc7e4fed23f4405f77bc"}, {file = "sphinxcontrib_serializinghtml-1.1.4-py2.py3-none-any.whl", hash = "sha256:f242a81d423f59617a8e5cf16f5d4d74e28ee9a66f9e5b637a18082991db5a9a"}, ] +tensorboard = [ + {file = "tensorboard-1.15.0-py2-none-any.whl", hash = "sha256:612b789386aa1b2c4804e1961273b37f8e4dd97613f98bc90ff0402d24627f50"}, + {file = "tensorboard-1.15.0-py3-none-any.whl", hash = "sha256:4cad2c65f6011e51609b463014c014fd7c6ddd9c1263af1d4f18dd97ed88c2bc"}, +] +tensorflow = [ + {file = "tensorflow-1.15.5-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:64c7c3ff7e7506a3b4d48174e9217066a99be59a1d18463a585f3145bad59f0b"}, + {file = "tensorflow-1.15.5-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:530c35578b48462df88253e9196f7fbe1815e2932a340295b025072b58d6e3da"}, + {file = "tensorflow-1.15.5-cp36-cp36m-win_amd64.whl", hash = "sha256:ef95b6b5b9d408a0181575b0ae82ab1fbd99474a528c546d01939bff26de681a"}, + {file = "tensorflow-1.15.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c9c73bb0302dbfd7d4a76dc7024ff58b23016633e2ce8295a4ec213d75e51f1f"}, + {file = "tensorflow-1.15.5-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:29831dda98d668067de75403b2fca0d06a2f026ef6f217fa2ca873c20b4ee4d3"}, + {file = "tensorflow-1.15.5-cp37-cp37m-win_amd64.whl", hash = "sha256:030453973e837301d08ab1a5cbd4adc87876216843861c71bc6429769ec596b0"}, +] +tensorflow-estimator = [ + {file = "tensorflow_estimator-1.15.1-py2.py3-none-any.whl", hash = "sha256:8853bfb7c3c96fbdc80b3d66c37a10af6ccbcd235dc87474764270c02a0f86b9"}, +] +tensorflow-hub = [ + {file = "tensorflow_hub-0.11.0-py2.py3-none-any.whl", hash = "sha256:19399a8abef10682b4f739a5aa78b43da3937df17f5d2afb0547945798787674"}, +] +termcolor = [ + {file = "termcolor-1.1.0.tar.gz", hash = "sha256:1d6d69ce66211143803fbc56652b41d73b4a400a2891d7bf7a1cdf4c02de613b"}, +] terminado = [ - {file = "terminado-0.9.3-py3-none-any.whl", hash = "sha256:430e876ec9d4d93a4fd8a49e82dcfae0c25f846540d0c5ca774b397533e237e8"}, - {file = "terminado-0.9.3.tar.gz", hash = "sha256:261c0b7825fecf629666e1820b484a5380f7e54d6b8bd889fa482e99dcf9bde4"}, + {file = "terminado-0.9.4-py3-none-any.whl", hash = "sha256:daed77f9fad7b32558fa84b226a76f45a02242c20813502f36c4e1ade6d8f1ad"}, + {file = "terminado-0.9.4.tar.gz", hash = "sha256:9a7dbcfbc2778830eeb70261bf7aa9d98a3eac8631a3afe3febeb57c12f798be"}, ] testpath = [ {file = "testpath-0.4.4-py2.py3-none-any.whl", hash = "sha256:bfcf9411ef4bf3db7579063e0546938b1edda3d69f4e1fb8756991f5951f85d4"}, @@ -2570,7 +3007,18 @@ webencodings = [ {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, ] +werkzeug = [ + {file = "Werkzeug-1.0.1-py2.py3-none-any.whl", hash = "sha256:2de2a5db0baeae7b2d2664949077c2ac63fbd16d98da0ff71837f7d1dea3fd43"}, + {file = "Werkzeug-1.0.1.tar.gz", hash = "sha256:6c80b1e5ad3665290ea39320b91e1be1e0d5f60652b964a3070216de83d2e47c"}, +] widgetsnbextension = [ {file = "widgetsnbextension-3.5.1-py2.py3-none-any.whl", hash = "sha256:bd314f8ceb488571a5ffea6cc5b9fc6cba0adaf88a9d2386b93a489751938bcd"}, {file = "widgetsnbextension-3.5.1.tar.gz", hash = "sha256:079f87d87270bce047512400efd70238820751a11d2d8cb137a5a5bdbaf255c7"}, ] +wrapt = [ + {file = "wrapt-1.12.1.tar.gz", hash = "sha256:b62ffa81fb85f4332a4f609cab4ac40709470da05643a082ec1eb88e6d9b97d7"}, +] +zipp = [ + {file = "zipp-3.4.1-py3-none-any.whl", hash = "sha256:51cb66cc54621609dd593d1787f286ee42a5c0adbb4b29abea5a63edc3e03098"}, + {file = "zipp-3.4.1.tar.gz", hash = "sha256:3607921face881ba3e026887d8150cca609d517579abe052ac81fc5aeffdbd76"}, +] diff --git a/pyproject.toml b/pyproject.toml index 2b1868b8c..1be4eeb92 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,12 +28,14 @@ version = "0.0.1-alpha.5" [tool.poetry.dependencies] astropy = "^4.2" galsim = "^2.2.4" +galsim-hub = {version = "^0.0.1-rc.4", optional = true} matplotlib = "^3.3.3" numpy = "^1.18.5" -python = "^3.8" +python = "~3.7" scikit-image = "^0.18.0" scipy = "^1.4.1" sep = "^1.1.1" +tensorflow = {version = "~1.15", optional = true} [tool.poetry.dev-dependencies] Cython = "^0.29.21" @@ -54,10 +56,13 @@ wheel = "^0.36.2" [tool.poetry.urls] "Bug Tracker" = "https://github.com/LSSTDESC/BlendingToolKit/issues" -[build-system] -build-backend = "poetry.core.masonry.api" -requires = ["poetry-core>=1.0.0"] - [tool.black] line-length = 100 target-version = ['py38'] + +[tool.poetry.extras] +galsim-hub = ["galsim-hub"] + +[build-system] +build-backend = "poetry.core.masonry.api" +requires = ["poetry-core>=1.0.0"] diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 3ae8fd7b6..000000000 --- a/requirements.txt +++ /dev/null @@ -1,967 +0,0 @@ -alabaster==0.7.12; python_version >= "3.6" \ - --hash=sha256:446438bdcca0e05bd45ea2de1668c1d9b032e1a9154c2c259092d77031ddd359 \ - --hash=sha256:a661d72d58e6ea8a57f7a86e37d86716863ee5e92788398526d58b26a4e4dc02 -appdirs==1.4.4; python_version >= "3.6" and python_full_version >= "3.6.1" \ - --hash=sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128 \ - --hash=sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41 -appnope==0.1.2; sys_platform == "darwin" and python_version >= "3.7" and platform_system == "Darwin" \ - --hash=sha256:93aa393e9d6c54c5cd570ccadd8edad61ea0c4b9ea7a01409020c9aa019eb442 \ - --hash=sha256:dd83cd4b5b460958838f6eb3000c660b1f9caf2a5b1de4264e941512f603258a -argon2-cffi==20.1.0; python_version >= "3.6" \ - --hash=sha256:d8029b2d3e4b4cea770e9e5a0104dd8fa185c1724a0f01528ae4826a6d25f97d \ - --hash=sha256:6ea92c980586931a816d61e4faf6c192b4abce89aa767ff6581e6ddc985ed003 \ - --hash=sha256:05a8ac07c7026542377e38389638a8a1e9b78f1cd8439cd7493b39f08dd75fbf \ - --hash=sha256:0bf066bc049332489bb2d75f69216416329d9dc65deee127152caeb16e5ce7d5 \ - --hash=sha256:57358570592c46c420300ec94f2ff3b32cbccd10d38bdc12dc6979c4a8484fbc \ - --hash=sha256:7d455c802727710e9dfa69b74ccaab04568386ca17b0ad36350b622cd34606fe \ - --hash=sha256:b160416adc0f012fb1f12588a5e6954889510f82f698e23ed4f4fa57f12a0647 \ - --hash=sha256:9bee3212ba4f560af397b6d7146848c32a800652301843df06b9e8f68f0f7361 \ - --hash=sha256:392c3c2ef91d12da510cfb6f9bae52512a4552573a9e27600bdb800e05905d2b \ - --hash=sha256:ba7209b608945b889457f949cc04c8e762bed4fe3fec88ae9a6b7765ae82e496 \ - --hash=sha256:da7f0445b71db6d3a72462e04f36544b0de871289b0bc8a7cc87c0f5ec7079fa \ - --hash=sha256:cc0e028b209a5483b6846053d5fd7165f460a1f14774d79e632e75e7ae64b82b \ - --hash=sha256:18dee20e25e4be86680b178b35ccfc5d495ebd5792cd00781548d50880fee5c5 \ - --hash=sha256:6678bb047373f52bcff02db8afab0d2a77d83bde61cfecea7c5c62e2335cb203 \ - --hash=sha256:77e909cc756ef81d6abb60524d259d959bab384832f0c651ed7dcb6e5ccdbb78 \ - --hash=sha256:9dfd5197852530294ecb5795c97a823839258dfd5eb9420233c7cfedec2058f2 \ - --hash=sha256:e2db6e85c057c16d0bd3b4d2b04f270a7467c147381e8fd73cbbe5bc719832be \ - --hash=sha256:8a84934bd818e14a17943de8099d41160da4a336bcc699bb4c394bbb9b94bd32 -aspy.refactor-imports==2.2.0; python_full_version >= "3.6.1" \ - --hash=sha256:7a18039d2e8be6b02b4791ce98891deb46b459b575c52ed35ab818c4eaa0c098 \ - --hash=sha256:78ca24122963fd258ebfc4a8dc708d23a18040ee39dca8767675821e84e9ea0a -astropy==4.2; python_version >= "3.7" \ - --hash=sha256:882434f6fe29a2aba9fe61bddac13943c95a9d6e8fdb19f3e35a9f9ae039bd10 \ - --hash=sha256:2fea9cf1fb1ef4e68e5c93c679a26dcc6313be55783fa1ee162eb72c8c9eb0b4 \ - --hash=sha256:4f33707d1bafd11884fc4aacc38f76f4c5c6f8d6f15dd968aad50bc197bc6edb \ - --hash=sha256:e749b2ecfedceac0e316a5332eaf73c833d2f5e1c3b9524a4780105dc802f27b \ - --hash=sha256:c9d65d0071215995e1e637bc74e84afcf37fc5492e54451015981f2cb6ca9e60 \ - --hash=sha256:a6890ec88220e2cbeaa1f70f012b19b4ffe908b19e3c264847ca87b710d5918f \ - --hash=sha256:ddaa04ba229b69c7a16efdd16dac77fcf8eb8923272cdc290b033992fe679323 \ - --hash=sha256:6767b8dd29be6c7ec5d934b955875b71400464b2a33eb58b59d575302e4a1892 \ - --hash=sha256:3638fd0c489fe4321d72056086acbdd48f767b19af8f6c39b865966c638e0efa \ - --hash=sha256:e80117502290e97819e2328243221d89f3749c14526f3ad7c75613a07b56ae8e \ - --hash=sha256:daaf9f0264b686c870032987483f2ddbdd5ce31762ab53f53f84bf9c68e2720a \ - --hash=sha256:1b3d6e801ab719d448e179dffe23a2f3c5646b81090db9f4d95a6b3acd643888 \ - --hash=sha256:ae3d690b6c20ce47d0644129046c08b7715cbafd2e7a49aba8d7c169dcfadbc1 \ - --hash=sha256:21c293609741bb7e3fe43e0c9f906f41962b04bb8c799a221fc1aa2100353fad \ - --hash=sha256:949b6111badc371129d811b74d7fe6df711719e41385b37189af0a4d325b811d \ - --hash=sha256:2c194f8a429b8399de64a413a06881ea49f0525cabaa2d78fc132b9e970adc6a -async-generator==1.10; python_full_version >= "3.6.1" and python_version >= "3.6" \ - --hash=sha256:01c7bf666359b4967d2cda0000cc2e4af16a0ae098cbffcb8472fb9e8ad6585b \ - --hash=sha256:6ebb3d106c12920aaae42ccb6f787ef5eefdcdd166ea3d628fa8476abe712144 -atomicwrites==1.4.0; python_version >= "3.6" and python_full_version < "3.0.0" and sys_platform == "win32" and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6") or sys_platform == "win32" and python_version >= "3.6" and python_full_version >= "3.4.0" and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6") \ - --hash=sha256:6d1784dea7c0c8d4a5172b6c620f40b6e4cbfdf96d783691f2e1302a7b88e197 \ - --hash=sha256:ae70396ad1a434f9c7046fd2dd196fc04b12f9e91ffb859164193be8b6168a7a -attrs==20.3.0; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:31b2eced602aa8423c2aea9c76a724617ed67cf9513173fd3a4f03e3a929c7e6 \ - --hash=sha256:832aa3cde19744e49938b91fea06d69ecb9e649c93ba974535d08ad92164f700 -babel==2.9.0; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.6" \ - --hash=sha256:9d35c22fcc79893c3ecc85ac4a56cde1ecf3f19c540bba0922308a6c06ca6fa5 \ - --hash=sha256:da031ab54472314f210b0adcff1588ee5d1d1d0ba4dbd07b94dba82bde791e05 -backcall==0.2.0; python_version >= "3.7" \ - --hash=sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255 \ - --hash=sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e -black==20.8b1; python_version >= "3.6" \ - --hash=sha256:1c02557aa099101b9d21496f8a914e9ed2222ef70336404eeeac8edba836fbea -bleach==3.3.0; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:6123ddc1052673e52bab52cdc955bcb57a015264a1c57d37bea2f6b817af0125 \ - --hash=sha256:98b3170739e5e83dd9dc19633f074727ad848cbedb6026708c8ac2d3b697a433 -cached-property==1.5.2; python_full_version >= "3.6.1" \ - --hash=sha256:9fa5755838eecbb2d234c3aa390bd80fbd3ac6b6869109bfc1b499f7bd89a130 \ - --hash=sha256:df4f613cf7ad9a588cc381aaf4a512d26265ecebd5eb9e1ba12f1319eb85a6a0 -certifi==2020.12.5; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:719a74fb9e33b9bd44cc7f3a8d94bc35e4049deebe19ba7d8e108280cfd59830 \ - --hash=sha256:1a4995114262bffbc2413b159f2a1a480c969de6e6eb13ee966d470af86af59c -cffi==1.14.5; implementation_name == "pypy" and python_version >= "3.6" \ - --hash=sha256:bb89f306e5da99f4d922728ddcd6f7fcebb3241fc40edebcb7284d7514741991 \ - --hash=sha256:34eff4b97f3d982fb93e2831e6750127d1355a923ebaeeb565407b3d2f8d41a1 \ - --hash=sha256:99cd03ae7988a93dd00bcd9d0b75e1f6c426063d6f03d2f90b89e29b25b82dfa \ - --hash=sha256:65fa59693c62cf06e45ddbb822165394a288edce9e276647f0046e1ec26920f3 \ - --hash=sha256:51182f8927c5af975fece87b1b369f722c570fe169f9880764b1ee3bca8347b5 \ - --hash=sha256:43e0b9d9e2c9e5d152946b9c5fe062c151614b262fda2e7b201204de0b99e482 \ - --hash=sha256:cbde590d4faaa07c72bf979734738f328d239913ba3e043b1e98fe9a39f8b2b6 \ - --hash=sha256:5de7970188bb46b7bf9858eb6890aad302577a5f6f75091fd7cdd3ef13ef3045 \ - --hash=sha256:a465da611f6fa124963b91bf432d960a555563efe4ed1cc403ba5077b15370aa \ - --hash=sha256:d42b11d692e11b6634f7613ad8df5d6d5f8875f5d48939520d351007b3c13406 \ - --hash=sha256:72d8d3ef52c208ee1c7b2e341f7d71c6fd3157138abf1a95166e6165dd5d4369 \ - --hash=sha256:29314480e958fd8aab22e4a58b355b629c59bf5f2ac2492b61e3dc06d8c7a315 \ - --hash=sha256:3d3dd4c9e559eb172ecf00a2a7517e97d1e96de2a5e610bd9b68cea3925b4892 \ - --hash=sha256:48e1c69bbacfc3d932221851b39d49e81567a4d4aac3b21258d9c24578280058 \ - --hash=sha256:69e395c24fc60aad6bb4fa7e583698ea6cc684648e1ffb7fe85e3c1ca131a7d5 \ - --hash=sha256:9e93e79c2551ff263400e1e4be085a1210e12073a31c2011dbbda14bda0c6132 \ - --hash=sha256:58e3f59d583d413809d60779492342801d6e82fefb89c86a38e040c16883be53 \ - --hash=sha256:005a36f41773e148deac64b08f233873a4d0c18b053d37da83f6af4d9087b813 \ - --hash=sha256:2894f2df484ff56d717bead0a5c2abb6b9d2bf26d6960c4604d5c48bbc30ee73 \ - --hash=sha256:0857f0ae312d855239a55c81ef453ee8fd24136eaba8e87a2eceba644c0d4c06 \ - --hash=sha256:cd2868886d547469123fadc46eac7ea5253ea7fcb139f12e1dfc2bbd406427d1 \ - --hash=sha256:35f27e6eb43380fa080dccf676dece30bef72e4a67617ffda586641cd4508d49 \ - --hash=sha256:9ff227395193126d82e60319a673a037d5de84633f11279e336f9c0f189ecc62 \ - --hash=sha256:9cf8022fb8d07a97c178b02327b284521c7708d7c71a9c9c355c178ac4bbd3d4 \ - --hash=sha256:8b198cec6c72df5289c05b05b8b0969819783f9418e0409865dac47288d2a053 \ - --hash=sha256:ad17025d226ee5beec591b52800c11680fca3df50b8b29fe51d882576e039ee0 \ - --hash=sha256:6c97d7350133666fbb5cf4abdc1178c812cb205dc6f41d174a7b0f18fb93337e \ - --hash=sha256:8ae6299f6c68de06f136f1f9e69458eae58f1dacf10af5c17353eae03aa0d827 \ - --hash=sha256:b85eb46a81787c50650f2392b9b4ef23e1f126313b9e0e9013b35c15e4288e2e \ - --hash=sha256:1f436816fc868b098b0d63b8920de7d208c90a67212546d02f84fe78a9c26396 \ - --hash=sha256:1071534bbbf8cbb31b498d5d9db0f274f2f7a865adca4ae429e147ba40f73dea \ - --hash=sha256:9de2e279153a443c656f2defd67769e6d1e4163952b3c622dcea5b08a6405322 \ - --hash=sha256:6e4714cc64f474e4d6e37cfff31a814b509a35cb17de4fb1999907575684479c \ - --hash=sha256:158d0d15119b4b7ff6b926536763dc0714313aa59e320ddf787502c70c4d4bee \ - --hash=sha256:afb29c1ba2e5a3736f1c301d9d0abe3ec8b86957d04ddfa9d7a6a42b9367e396 \ - --hash=sha256:f2d45f97ab6bb54753eab54fffe75aaf3de4ff2341c9daee1987ee1837636f1d \ - --hash=sha256:fd78e5fee591709f32ef6edb9a015b4aa1a5022598e36227500c8f4e02328d9c -cfgv==3.2.0; python_full_version >= "3.6.1" \ - --hash=sha256:32e43d604bbe7896fe7c248a9c2276447dbef840feb28fe20494f62af110211d \ - --hash=sha256:cf22deb93d4bcf92f345a5c3cd39d3d41d6340adc60c78bbbd6588c384fda6a1 -chardet==4.0.0; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5 \ - --hash=sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa -click==7.1.2; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:dacca89f4bfadd5de3d7489b7c8a566eee0d3676333fbb50030263894c38c0dc \ - --hash=sha256:d2b5255c7c6349bc1bd1e59e08cd12acbbd63ce649f2588755783aa94dfb6b1a -colorama==0.4.4; python_version >= "3.7" and python_full_version < "3.0.0" and sys_platform == "win32" and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6") or sys_platform == "win32" and python_version >= "3.7" and python_full_version >= "3.5.0" and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6") \ - --hash=sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2 \ - --hash=sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b -coverage==5.5; python_version >= "2.7" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version < "4" \ - --hash=sha256:b6d534e4b2ab35c9f93f46229363e17f63c53ad01330df9f2d6bd1187e5eaacf \ - --hash=sha256:b7895207b4c843c76a25ab8c1e866261bcfe27bfaa20c192de5190121770672b \ - --hash=sha256:c2723d347ab06e7ddad1a58b2a821218239249a9e4365eaff6649d31180c1669 \ - --hash=sha256:900fbf7759501bc7807fd6638c947d7a831fc9fdf742dc10f02956ff7220fa90 \ - --hash=sha256:004d1880bed2d97151facef49f08e255a20ceb6f9432df75f4eef018fdd5a78c \ - --hash=sha256:06191eb60f8d8a5bc046f3799f8a07a2d7aefb9504b0209aff0b47298333302a \ - --hash=sha256:7501140f755b725495941b43347ba8a2777407fc7f250d4f5a7d2a1050ba8e82 \ - --hash=sha256:372da284cfd642d8e08ef606917846fa2ee350f64994bebfbd3afb0040436905 \ - --hash=sha256:8963a499849a1fc54b35b1c9f162f4108017b2e6db2c46c1bed93a72262ed083 \ - --hash=sha256:869a64f53488f40fa5b5b9dcb9e9b2962a66a87dab37790f3fcfb5144b996ef5 \ - --hash=sha256:4a7697d8cb0f27399b0e393c0b90f0f1e40c82023ea4d45d22bce7032a5d7b81 \ - --hash=sha256:8d0a0725ad7c1a0bcd8d1b437e191107d457e2ec1084b9f190630a4fb1af78e6 \ - --hash=sha256:51cb9476a3987c8967ebab3f0fe144819781fca264f57f89760037a2ea191cb0 \ - --hash=sha256:c0891a6a97b09c1f3e073a890514d5012eb256845c451bd48f7968ef939bf4ae \ - --hash=sha256:3487286bc29a5aa4b93a072e9592f22254291ce96a9fbc5251f566b6b7343cdb \ - --hash=sha256:deee1077aae10d8fa88cb02c845cfba9b62c55e1183f52f6ae6a2df6a2187160 \ - --hash=sha256:f11642dddbb0253cc8853254301b51390ba0081750a8ac03f20ea8103f0c56b6 \ - --hash=sha256:6c90e11318f0d3c436a42409f2749ee1a115cd8b067d7f14c148f1ce5574d701 \ - --hash=sha256:30c77c1dc9f253283e34c27935fded5015f7d1abe83bc7821680ac444eaf7793 \ - --hash=sha256:9a1ef3b66e38ef8618ce5fdc7bea3d9f45f3624e2a66295eea5e57966c85909e \ - --hash=sha256:972c85d205b51e30e59525694670de6a8a89691186012535f9d7dbaa230e42c3 \ - --hash=sha256:af0e781009aaf59e25c5a678122391cb0f345ac0ec272c7961dc5455e1c40066 \ - --hash=sha256:74d881fc777ebb11c63736622b60cb9e4aee5cace591ce274fb69e582a12a61a \ - --hash=sha256:92b017ce34b68a7d67bd6d117e6d443a9bf63a2ecf8567bb3d8c6c7bc5014465 \ - --hash=sha256:d636598c8305e1f90b439dbf4f66437de4a5e3c31fdf47ad29542478c8508bbb \ - --hash=sha256:41179b8a845742d1eb60449bdb2992196e211341818565abded11cfa90efb821 \ - --hash=sha256:040af6c32813fa3eae5305d53f18875bedd079960822ef8ec067a66dd8afcd45 \ - --hash=sha256:5fec2d43a2cc6965edc0bb9e83e1e4b557f76f843a77a2496cbe719583ce8184 \ - --hash=sha256:18ba8bbede96a2c3dde7b868de9dcbd55670690af0988713f0603f037848418a \ - --hash=sha256:2910f4d36a6a9b4214bb7038d537f015346f413a975d57ca6b43bf23d6563b53 \ - --hash=sha256:f0b278ce10936db1a37e6954e15a3730bea96a0997c26d7fee88e6c396c2086d \ - --hash=sha256:796c9c3c79747146ebd278dbe1e5c5c05dd6b10cc3bcb8389dfdf844f3ead638 \ - --hash=sha256:53194af30d5bad77fcba80e23a1441c71abfb3e01192034f8246e0d8f99528f3 \ - --hash=sha256:184a47bbe0aa6400ed2d41d8e9ed868b8205046518c52464fde713ea06e3a74a \ - --hash=sha256:2949cad1c5208b8298d5686d5a85b66aae46d73eec2c3e08c817dd3513e5848a \ - --hash=sha256:217658ec7187497e3f3ebd901afdca1af062b42cfe3e0dafea4cced3983739f6 \ - --hash=sha256:1aa846f56c3d49205c952d8318e76ccc2ae23303351d9270ab220004c580cfe2 \ - --hash=sha256:24d4a7de75446be83244eabbff746d66b9240ae020ced65d060815fac3423759 \ - --hash=sha256:d1f8bf7b90ba55699b3a5e44930e93ff0189aa27186e96071fac7dd0d06a1873 \ - --hash=sha256:970284a88b99673ccb2e4e334cfb38a10aab7cd44f7457564d11898a74b62d0a \ - --hash=sha256:01d84219b5cdbfc8122223b39a954820929497a1cb1422824bb86b07b74594b6 \ - --hash=sha256:2e0d881ad471768bf6e6c2bf905d183543f10098e3b3640fc029509530091502 \ - --hash=sha256:d1f9ce122f83b2305592c11d64f181b87153fc2c2bbd3bb4a3dde8303cfb1a6b \ - --hash=sha256:13c4ee887eca0f4c5a247b75398d4114c37882658300e153113dafb1d76de529 \ - --hash=sha256:52596d3d0e8bdf3af43db3e9ba8dcdaac724ba7b5ca3f6358529d56f7a166f8b \ - --hash=sha256:2cafbbb3af0733db200c9b5f798d18953b1a304d3f86a938367de1567f4b5bff \ - --hash=sha256:44d654437b8ddd9eee7d1eaee28b7219bec228520ff809af170488fd2fed3e2b \ - --hash=sha256:d314ed732c25d29775e84a960c3c60808b682c08d86602ec2c3008e1202e3bb6 \ - --hash=sha256:13034c4409db851670bc9acd836243aeee299949bd5673e11844befcb0149f03 \ - --hash=sha256:f030f8873312a16414c0d8e1a1ddff2d3235655a2174e3648b4fa66b3f2f1079 \ - --hash=sha256:2a3859cb82dcbda1cfd3e6f71c27081d18aa251d20a17d87d26d4cd216fb0af4 \ - --hash=sha256:ebe78fe9a0e874362175b02371bdfbee64d8edc42a044253ddf4ee7d3c15212c -cycler==0.10.0; python_version >= "3.7" \ - --hash=sha256:1d8a5ae1ff6c5cf9b93e8811e581232ad8920aeec647c37316ceac982b08cb2d \ - --hash=sha256:cd7b2d1018258d7247a71425e9f26463dfb444d411c39569972f4ce586b0c9d8 -cython==0.29.22; (python_version >= "2.6" and python_full_version < "3.0.0") or (python_full_version >= "3.3.0") \ - --hash=sha256:f89c19480d137026f04a34cbd54ab0fb328b29005c91d3a36d06b9c4710152c1 \ - --hash=sha256:667b169c89c4b8eb79d35822508ed8d77b9421af085142fad20bfef775a295d2 \ - --hash=sha256:59c950513c485f1e8da0e04a2a91f71508c5e98b6912ce66588c6aee72d8e4d1 \ - --hash=sha256:15b2ba47858d7949a036d4ba6e838120bf3c06983769e99d12867a2c8cd0cd91 \ - --hash=sha256:d76feb00f754d86e6d48f39b59a4e9a8fcfed1e6e3e433d18e3677ff19ff2911 \ - --hash=sha256:e8c84ad389b3f36433e1be88dd7a1e36db4ab5b4848f5899cbd0a1cdc443b925 \ - --hash=sha256:105d813eedf276588a02a240ece2f7bca8235aee9bb48e25293410c3c1ac7230 \ - --hash=sha256:af646d37e23fc3ba217c587096fac4e57006d8173d2a2365763287071e0eec2d \ - --hash=sha256:d73a4851d1dbdcc70e619ccb104877d5e523d0fc5aef6fb6fbba4344c1f60cae \ - --hash=sha256:88bebb8803adac0b64426fd261752925e8bf301b1986078e9506670bcbb5307f \ - --hash=sha256:7265abb33f154663a052c47213b978ec703f89a938bca38f425f25d4e8ba2211 \ - --hash=sha256:f7064df99094b4fd09c9ebcca6c94a652fac04c7dce514a4f2ab6ce23fcd0ba4 \ - --hash=sha256:97511722515b66851d3f77d64b1970a97e5114c4007efd5a0a307936e156a24c \ - --hash=sha256:ab4c34d8693a62f1b8261a131784a3db397ceaa03ea90a5799574623acaa2c2c \ - --hash=sha256:6609babc68d37bb92a1b85ebd867405f720aeb2a6af946f6bd7f71b22dbb91cf \ - --hash=sha256:40a87c9ecd0b1b485804c70b16427e88bd07bff9f270d022d872869ff4d6ac6e \ - --hash=sha256:ba7f34e07ca0d1ce4ba8d9e3da6d2eb0b1ac6cb9896d2c821b28a9ac9504bcfe \ - --hash=sha256:a8aee32da407f215652959fc6568277cfd35a24714a5238c8a9778bf34d91ace \ - --hash=sha256:92c028e0d4ac9e32b2cf6c970f7f6c5c3aaa87f011798201ef56746705a8f01a \ - --hash=sha256:c4f2c8cceffd8403468b542570826174564fe2c6549dd199a75c13720add4981 \ - --hash=sha256:761b965b5abcea072ba642dbb740e44532bc88618f34b605c05de1d6088b1cdd \ - --hash=sha256:a6f5bf7fece95dd62ba13a9edb7d3ecc1a9097e6f0fde78c5fad763163157472 \ - --hash=sha256:bbc48be45ee9eba2d0268bf616220cfb46d998ad85524f3cf752d55eb6dd3379 \ - --hash=sha256:3ce10572a6b7fd5baa755f11cdf09830ae518e6f837aa38c31ec534b1f874fd4 \ - --hash=sha256:b53c9d7b545c70f462408000affdd330cb87d05f83a58a9ccd72d19c8df80d56 \ - --hash=sha256:fedecbd2ad6535e30dd3b43ca9b493a1930d5167257a3fb60687bd425f6fdc54 \ - --hash=sha256:182e78d75515e3d50f31cfde501fbf2af7ee0698e8149f41048db5d3c98ffc8f \ - --hash=sha256:5cc5e72a106d7abc12b6e58883c914bce0b2031df6035014094a15593052db12 \ - --hash=sha256:dc42b78b62815abea19a37d186011cca57f72ec509f56fa6c43a71b2e8c6a24f \ - --hash=sha256:f5f57b2e13cc3aa95526145ffa551df529f04bf5d137c59350e7accff9362dc0 \ - --hash=sha256:df6b83c7a6d1d967ea89a2903e4a931377634a297459652e4551734c48195406 -decorator==4.4.2; python_version >= "3.7" and python_full_version < "3.0.0" or python_full_version >= "3.2.0" and python_version >= "3.7" \ - --hash=sha256:41fa54c2a0cc4ba648be4fd43cff00aedf5b9465c9bf18d64325bc225f08f760 \ - --hash=sha256:e3a62f0520172440ca0dcc823749319382e377f37f140a0b99ef45fecb84bfe7 -defusedxml==0.7.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61 \ - --hash=sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69 -distlib==0.3.1; python_full_version >= "3.6.1" \ - --hash=sha256:8c09de2c67b3e7deef7184574fc060ab8a793e7adbb183d942c389c8b13c52fb \ - --hash=sha256:edf6116872c863e1aa9d5bb7cb5e05a022c519a4594dc703843343a9ddd9bff1 -docutils==0.16; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:0c5b78adfbf7762415433f5515cd5c9e762339e23369dbe8000d84a4bf4ab3af \ - --hash=sha256:c2de3a60e9e7d07be26b7f2b00ca0309c207e06c100f9cc2a94931fc75a478fc -entrypoints==0.3; python_version >= "3.6" \ - --hash=sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19 \ - --hash=sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451 -filelock==3.0.12; python_full_version >= "3.6.1" \ - --hash=sha256:929b7d63ec5b7d6b71b0fa5ac14e030b3f70b75747cef1b10da9b879fef15836 \ - --hash=sha256:18d82244ee114f543149c66a6e0c14e9c4f8a1044b5cdaadd0f82159d6a6ff59 -flake8-absolute-import==1.0; python_version >= "3.4" \ - --hash=sha256:06f2784078d91e52812dac10c77e09515916c4e455c8bb15cc538fb95f20d9a3 \ - --hash=sha256:8ea7e60817038133dd7a0d8b5719b955bc22317ab35c7d247b1a2985f96cf8d4 -flake8==3.9.0; (python_version >= "2.7" and python_full_version < "3.0.0") or (python_full_version >= "3.5.0") \ - --hash=sha256:12d05ab02614b6aee8df7c36b97d1a3b2372761222b19b58621355e82acddcff \ - --hash=sha256:78873e372b12b093da7b5e5ed302e8ad9e988b38b063b61ad937f26ca58fc5f0 -future==0.18.2; python_version >= "2.6" and python_full_version < "3.0.0" or python_full_version >= "3.3.0" \ - --hash=sha256:b1bead90b70cf6ec3f0710ae53a525360fa360d306a86583adc6bf83a4db537d -galsim==2.2.5 \ - --hash=sha256:a265d7af9862307890a3609ffad2a50717818884099b03612ae7b946683331c3 -identify==2.1.3; python_full_version >= "3.6.1" \ - --hash=sha256:46d1816c6a4fc2d1e8758f293a5dcc1ae6404ab344179d7c1e73637bf283beb1 \ - --hash=sha256:ed4a05fb80e3cbd12e83c959f9ff7f729ba6b66ab8d6178850fd5cb4c1cf6c5d -idna==2.10; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0 \ - --hash=sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6 -imageio==2.9.0; python_version >= "3.7" \ - --hash=sha256:3604d751f03002e8e0e7650aa71d8d9148144a87daf17cb1f3228e80747f2e6b \ - --hash=sha256:52ddbaeca2dccf53ba2d6dec5676ca7bc3b2403ef8b37f7da78b7654bb3e10f0 -imagesize==1.2.0; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.6" \ - --hash=sha256:6965f19a6a2039c7d48bca7dba2473069ff854c36ae6f19d2cde309d998228a1 \ - --hash=sha256:b1f6b5a4eab1f73479a50fb79fcf729514a900c341d8503d62a62dbc4127a2b1 -iniconfig==1.1.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3 \ - --hash=sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32 -ipykernel==5.5.0; python_version >= "3.6" \ - --hash=sha256:efd07253b54d84d26e0878d268c8c3a41582a18750da633c2febfd2ece0d467d \ - --hash=sha256:98321abefdf0505fb3dc7601f60fc4087364d394bd8fad53107eb1adee9ff475 -ipython-genutils==0.2.0; python_version >= "3.7" \ - --hash=sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8 \ - --hash=sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8 -ipython==7.21.0; python_version >= "3.7" \ - --hash=sha256:34207ffb2f653bced2bc8e3756c1db86e7d93e44ed049daae9814fed66d408ec \ - --hash=sha256:04323f72d5b85b606330b6d7e2dc8d2683ad46c3905e955aa96ecc7a99388e70 -ipywidgets==7.6.3; python_version >= "3.6" \ - --hash=sha256:e6513cfdaf5878de30f32d57f6dc2474da395a2a2991b94d487406c0ab7f55ca \ - --hash=sha256:9f1a43e620530f9e570e4a493677d25f08310118d315b00e25a18f12913c41f0 -jedi==0.18.0; python_version >= "3.7" \ - --hash=sha256:18456d83f65f400ab0c2d3319e48520420ef43b23a086fdc05dff34132f0fb93 \ - --hash=sha256:92550a404bad8afed881a137ec9a461fed49eca661414be45059329614ed0707 -jinja2==2.11.3; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:03e47ad063331dd6a3f04a43eddca8a966a26ba0c5b7207a9a9e4e08f1b29419 \ - --hash=sha256:a6d58433de0ae800347cab1fa3043cebbabe8baa9d29e668f1c768cb87a333c6 -jsonschema==3.2.0; python_version >= "3.6" \ - --hash=sha256:4e5b3cf8216f577bee9ce139cbe72eca3ea4f292ec60928ff24758ce626cd163 \ - --hash=sha256:c8a85b28d377cc7737e46e2d9f2b4f44ee3c0e1deac6bf46ddefc7187d30797a -jupyter-client==6.1.12; python_full_version >= "3.6.1" and python_version >= "3.6" \ - --hash=sha256:e053a2c44b6fa597feebe2b3ecb5eea3e03d1d91cc94351a52931ee1426aecfc \ - --hash=sha256:c4bca1d0846186ca8be97f4d2fa6d2bae889cce4892a167ffa1ba6bd1f73e782 -jupyter-core==4.7.1; python_version >= "3.6" \ - --hash=sha256:8c6c0cac5c1b563622ad49321d5ec47017bd18b94facb381c6973a0486395f8e \ - --hash=sha256:79025cb3225efcd36847d0840f3fc672c0abd7afd0de83ba8a1d3837619122b4 -jupyter-sphinx==0.3.2; python_version >= "3.6" \ - --hash=sha256:301e36d0fb3007bb5802f6b65b60c24990eb99c983332a2ab6eecff385207dc9 \ - --hash=sha256:37fc9408385c45326ac79ca0452fbd7ae2bf0e97842d626d2844d4830e30aaf2 -jupyterlab-pygments==0.1.2; python_version >= "3.6" \ - --hash=sha256:abfb880fd1561987efaefcb2d2ac75145d2a5d0139b1876d5be806e32f630008 \ - --hash=sha256:cfcda0873626150932f438eccf0f8bf22bfa92345b814890ab360d666b254146 -jupyterlab-widgets==1.0.0; python_version >= "3.6" \ - --hash=sha256:caeaf3e6103180e654e7d8d2b81b7d645e59e432487c1d35a41d6d3ee56b3fef \ - --hash=sha256:5c1a29a84d3069208cb506b10609175b249b6486d6b1cbae8fcde2a11584fb78 -kiwisolver==1.3.1; python_version >= "3.7" \ - --hash=sha256:fd34fbbfbc40628200730bc1febe30631347103fc8d3d4fa012c21ab9c11eca9 \ - --hash=sha256:d3155d828dec1d43283bd24d3d3e0d9c7c350cdfcc0bd06c0ad1209c1bbc36d0 \ - --hash=sha256:5a7a7dbff17e66fac9142ae2ecafb719393aaee6a3768c9de2fd425c63b53e21 \ - --hash=sha256:f8d6f8db88049a699817fd9178782867bf22283e3813064302ac59f61d95be05 \ - --hash=sha256:5f6ccd3dd0b9739edcf407514016108e2280769c73a85b9e59aa390046dbf08b \ - --hash=sha256:225e2e18f271e0ed8157d7f4518ffbf99b9450fca398d561eb5c4a87d0986dd9 \ - --hash=sha256:cf8b574c7b9aa060c62116d4181f3a1a4e821b2ec5cbfe3775809474113748d4 \ - --hash=sha256:232c9e11fd7ac3a470d65cd67e4359eee155ec57e822e5220322d7b2ac84fbf0 \ - --hash=sha256:b38694dcdac990a743aa654037ff1188c7a9801ac3ccc548d3341014bc5ca278 \ - --hash=sha256:ca3820eb7f7faf7f0aa88de0e54681bddcb46e485beb844fcecbcd1c8bd01689 \ - --hash=sha256:c8fd0f1ae9d92b42854b2979024d7597685ce4ada367172ed7c09edf2cef9cb8 \ - --hash=sha256:1e1bc12fb773a7b2ffdeb8380609f4f8064777877b2225dec3da711b421fda31 \ - --hash=sha256:72c99e39d005b793fb7d3d4e660aed6b6281b502e8c1eaf8ee8346023c8e03bc \ - --hash=sha256:8be8d84b7d4f2ba4ffff3665bcd0211318aa632395a1a41553250484a871d454 \ - --hash=sha256:31dfd2ac56edc0ff9ac295193eeaea1c0c923c0355bf948fbd99ed6018010b72 \ - --hash=sha256:563c649cfdef27d081c84e72a03b48ea9408c16657500c312575ae9d9f7bc1c3 \ - --hash=sha256:78751b33595f7f9511952e7e60ce858c6d64db2e062afb325985ddbd34b5c131 \ - --hash=sha256:a357fd4f15ee49b4a98b44ec23a34a95f1e00292a139d6015c11f55774ef10de \ - --hash=sha256:5989db3b3b34b76c09253deeaf7fbc2707616f130e166996606c284395da3f18 \ - --hash=sha256:c08e95114951dc2090c4a630c2385bef681cacf12636fb0241accdc6b303fd81 \ - --hash=sha256:44a62e24d9b01ba94ae7a4a6c3fb215dc4af1dde817e7498d901e229aaf50e4e \ - --hash=sha256:50af681a36b2a1dee1d3c169ade9fdc59207d3c31e522519181e12f1b3ba7000 \ - --hash=sha256:a53d27d0c2a0ebd07e395e56a1fbdf75ffedc4a05943daf472af163413ce9598 \ - --hash=sha256:834ee27348c4aefc20b479335fd422a2c69db55f7d9ab61721ac8cd83eb78882 \ - --hash=sha256:5c3e6455341008a054cccee8c5d24481bcfe1acdbc9add30aa95798e95c65621 \ - --hash=sha256:acef3d59d47dd85ecf909c359d0fd2c81ed33bdff70216d3956b463e12c38a54 \ - --hash=sha256:c5518d51a0735b1e6cee1fdce66359f8d2b59c3ca85dc2b0813a8aa86818a030 \ - --hash=sha256:b9edd0110a77fc321ab090aaa1cfcaba1d8499850a12848b81be2222eab648f6 \ - --hash=sha256:0cd53f403202159b44528498de18f9285b04482bab2a6fc3f5dd8dbb9352e30d \ - --hash=sha256:33449715e0101e4d34f64990352bce4095c8bf13bed1b390773fc0a7295967b3 \ - --hash=sha256:401a2e9afa8588589775fe34fc22d918ae839aaaf0c0e96441c0fdbce6d8ebe6 \ - --hash=sha256:950a199911a8d94683a6b10321f9345d5a3a8433ec58b217ace979e18f16e248 -lsstdesc.coord==1.2.1 \ - --hash=sha256:fbe8ed22222c69628def3685670b863339ce19fa5af6604e29d223cc0976d98a -markupsafe==1.1.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161 \ - --hash=sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7 \ - --hash=sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183 \ - --hash=sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b \ - --hash=sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e \ - --hash=sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f \ - --hash=sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1 \ - --hash=sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5 \ - --hash=sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1 \ - --hash=sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735 \ - --hash=sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21 \ - --hash=sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235 \ - --hash=sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b \ - --hash=sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f \ - --hash=sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905 \ - --hash=sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1 \ - --hash=sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d \ - --hash=sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff \ - --hash=sha256:d53bc011414228441014aa71dbec320c66468c1030aae3a6e29778a3382d96e5 \ - --hash=sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473 \ - --hash=sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e \ - --hash=sha256:3b8a6499709d29c2e2399569d96719a1b21dcd94410a586a18526b143ec8470f \ - --hash=sha256:84dee80c15f1b560d55bcfe6d47b27d070b4681c699c572af2e3c7cc90a3b8e0 \ - --hash=sha256:b1dba4527182c95a0db8b6060cc98ac49b9e2f5e64320e2b56e47cb2831978c7 \ - --hash=sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66 \ - --hash=sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5 \ - --hash=sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d \ - --hash=sha256:bf5aa3cbcfdf57fa2ee9cd1822c862ef23037f5c832ad09cfea57fa846dec193 \ - --hash=sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e \ - --hash=sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6 \ - --hash=sha256:6fffc775d90dcc9aed1b89219549b329a9250d918fd0b8fa8d93d154918422e1 \ - --hash=sha256:a6a744282b7718a2a62d2ed9d993cad6f5f585605ad352c11de459f4108df0a1 \ - --hash=sha256:195d7d2c4fbb0ee8139a6cf67194f3973a6b3042d742ebe0a9ed36d8b6f0c07f \ - --hash=sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2 \ - --hash=sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c \ - --hash=sha256:6788b695d50a51edb699cb55e35487e430fa21f1ed838122d722e0ff0ac5ba15 \ - --hash=sha256:cdb132fc825c38e1aeec2c8aa9338310d29d337bebbd7baa06889d09a60a1fa2 \ - --hash=sha256:13d3144e1e340870b25e7b10b98d779608c02016d5184cfb9927a9f10c689f42 \ - --hash=sha256:acf08ac40292838b3cbbb06cfe9b2cb9ec78fce8baca31ddb87aaac2e2dc3bc2 \ - --hash=sha256:d9be0ba6c527163cbed5e0857c451fcd092ce83947944d6c14bc95441203f032 \ - --hash=sha256:caabedc8323f1e93231b52fc32bdcde6db817623d33e100708d9a68e1f53b26b \ - --hash=sha256:596510de112c685489095da617b5bcbbac7dd6384aeebeda4df6025d0256a81b \ - --hash=sha256:e8313f01ba26fbbe36c7be1966a7b7424942f670f38e666995b88d012765b9be \ - --hash=sha256:d73a845f227b0bfe8a7455ee623525ee656a9e2e749e4742706d80a6065d5e2c \ - --hash=sha256:98bae9582248d6cf62321dcb52aaf5d9adf0bad3b40582925ef7c7f0ed85fceb \ - --hash=sha256:2beec1e0de6924ea551859edb9e7679da6e4870d32cb766240ce17e0a0ba2014 \ - --hash=sha256:7fed13866cf14bba33e7176717346713881f56d9d2bcebab207f7a036f41b850 \ - --hash=sha256:6f1e273a344928347c1290119b493a1f0303c52f5a5eae5f16d74f48c15d4a85 \ - --hash=sha256:feb7b34d6325451ef96bc0e36e1a6c0c1c64bc1fbec4b854f4529e51887b1621 \ - --hash=sha256:22c178a091fc6630d0d045bdb5992d2dfe14e3259760e713c490da5323866c39 \ - --hash=sha256:b7d644ddb4dbd407d31ffb699f1d140bc35478da613b441c582aeb7c43838dd8 \ - --hash=sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b -matplotlib==3.3.4; python_version >= "3.6" \ - --hash=sha256:672960dd114e342b7c610bf32fb99d14227f29919894388b41553217457ba7ef \ - --hash=sha256:7c155437ae4fd366e2700e2716564d1787700687443de46bcb895fe0f84b761d \ - --hash=sha256:a17f0a10604fac7627ec82820439e7db611722e80c408a726cd00d8c974c2fb3 \ - --hash=sha256:215e2a30a2090221a9481db58b770ce56b8ef46f13224ae33afe221b14b24dc1 \ - --hash=sha256:348e6032f666ffd151b323342f9278b16b95d4a75dfacae84a11d2829a7816ae \ - --hash=sha256:94bdd1d55c20e764d8aea9d471d2ae7a7b2c84445e0fa463f02e20f9730783e1 \ - --hash=sha256:a1acb72f095f1d58ecc2538ed1b8bca0b57df313b13db36ed34b8cdf1868e674 \ - --hash=sha256:46b1a60a04e6d884f0250d5cc8dc7bd21a9a96c584a7acdaab44698a44710bab \ - --hash=sha256:ed4a9e6dcacba56b17a0a9ac22ae2c72a35b7f0ef0693aa68574f0b2df607a89 \ - --hash=sha256:c24c05f645aef776e8b8931cb81e0f1632d229b42b6d216e30836e2e145a2b40 \ - --hash=sha256:7310e353a4a35477c7f032409966920197d7df3e757c7624fd842f3eeb307d3d \ - --hash=sha256:451cc89cb33d6652c509fc6b588dc51c41d7246afdcc29b8624e256b7663ed1f \ - --hash=sha256:3d2eb9c1cc254d0ffa90bc96fde4b6005d09c2228f99dfd493a4219c1af99644 \ - --hash=sha256:e15fa23d844d54e7b3b7243afd53b7567ee71c721f592deb0727ee85e668f96a \ - --hash=sha256:1de0bb6cbfe460725f0e97b88daa8643bcf9571c18ba90bb8e41432aaeca91d6 \ - --hash=sha256:f44149a0ef5b4991aaef12a93b8e8d66d6412e762745fea1faa61d98524e0ba9 \ - --hash=sha256:746a1df55749629e26af7f977ea426817ca9370ad1569436608dc48d1069b87c \ - --hash=sha256:5f571b92a536206f7958f7cb2d367ff6c9a1fa8229dc35020006e4cdd1ca0acd \ - --hash=sha256:9265ae0fb35e29f9b8cc86c2ab0a2e3dcddc4dd9de4b85bf26c0f63fe5c1c2ca \ - --hash=sha256:9a79e5dd7bb797aa611048f5b70588b23c5be05b63eefd8a0d152ac77c4243db \ - --hash=sha256:1e850163579a8936eede29fad41e202b25923a0a8d5ffd08ce50fc0a97dcdc93 \ - --hash=sha256:d738acfdfb65da34c91acbdb56abed46803db39af259b7f194dc96920360dbe4 \ - --hash=sha256:aa49571d8030ad0b9ac39708ee77bd2a22f87815e12bdee52ecaffece9313ed8 \ - --hash=sha256:cf3a7e54eff792f0815dbbe9b85df2f13d739289c93d346925554f71d484be78 \ - --hash=sha256:3e477db76c22929e4c6876c44f88d790aacdf3c3f8f3a90cb1975c0bf37825b0 -mccabe==0.6.1; python_version >= "3.4" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.4" \ - --hash=sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42 \ - --hash=sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f -mistune==0.8.4; python_version >= "3.6" \ - --hash=sha256:88a1051873018da288eee8538d476dffe1262495144b33ecb586c4ab266bb8d4 \ - --hash=sha256:59a3429db53c50b5c6bcc8a07f8848cb00d7dc8bdb431a4ab41920d201d4756e -mock==3.0.5; (python_version >= "2.7" and python_full_version < "3.0.0") or (python_full_version >= "3.4.0") \ - --hash=sha256:d157e52d4e5b938c550f39eb2fd15610db062441a9c2747d3dbfa9298211d0f8 \ - --hash=sha256:83657d894c90d5681d62155c82bda9c1187827525880eda8ff5df4ec813437c3 -mypy-extensions==0.4.3; python_version >= "3.6" \ - --hash=sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d \ - --hash=sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8 -nbclient==0.5.3; python_full_version >= "3.6.1" and python_version >= "3.6" \ - --hash=sha256:e79437364a2376892b3f46bedbf9b444e5396cfb1bc366a472c37b48e9551500 \ - --hash=sha256:db17271330c68c8c88d46d72349e24c147bb6f34ec82d8481a8f025c4d26589c -nbconvert==6.0.7; python_version >= "3.6" \ - --hash=sha256:39e9f977920b203baea0be67eea59f7b37a761caa542abe80f5897ce3cf6311d \ - --hash=sha256:cbbc13a86dfbd4d1b5dee106539de0795b4db156c894c2c5dc382062bbc29002 -nbformat==5.1.2; python_full_version >= "3.6.1" and python_version >= "3.6" \ - --hash=sha256:3949fdc8f5fa0b1afca16fb307546e78494fa7a7bceff880df8168eafda0e7ac \ - --hash=sha256:1d223e64a18bfa7cdf2db2e9ba8a818312fc2a0701d2e910b58df66809385a56 -nest-asyncio==1.5.1; python_full_version >= "3.6.1" and python_version >= "3.6" \ - --hash=sha256:76d6e972265063fe92a90b9cc4fb82616e07d586b346ed9d2c89a4187acea39c \ - --hash=sha256:afc5a1c515210a23c461932765691ad39e8eba6551c055ac8d5546e69250d0aa -networkx==2.5; python_version >= "3.7" \ - --hash=sha256:8c5812e9f798d37c50570d15c4a69d5710a18d77bafc903ee9c5fba7454c616c \ - --hash=sha256:7978955423fbc9639c10498878be59caf99b44dc304c2286162fd24b458c1602 -nodeenv==1.5.0; python_full_version >= "3.6.1" \ - --hash=sha256:5304d424c529c997bc888453aeaa6362d242b6b4631e90f3d4bf1b290f1c84a9 \ - --hash=sha256:ab45090ae383b716c4ef89e690c41ff8c2b257b85b309f01f3654df3d084bd7c -notebook==6.2.0; python_version >= "3.6" \ - --hash=sha256:25ad93c982b623441b491e693ef400598d1a46cdf11b8c9c0b3be6c61ebbb6cd \ - --hash=sha256:0464b28e18e7a06cec37e6177546c2322739be07962dd13bf712bcb88361f013 -numpy==1.20.1; python_version >= "3.7" \ - --hash=sha256:ae61f02b84a0211abb56462a3b6cd1e7ec39d466d3160eb4e1da8bf6717cdbeb \ - --hash=sha256:65410c7f4398a0047eea5cca9b74009ea61178efd78d1be9847fac1d6716ec1e \ - --hash=sha256:2d7e27442599104ee08f4faed56bb87c55f8b10a5494ac2ead5c98a4b289e61f \ - --hash=sha256:4ed8e96dc146e12c1c5cdd6fb9fd0757f2ba66048bf94c5126b7efebd12d0090 \ - --hash=sha256:ecb5b74c702358cdc21268ff4c37f7466357871f53a30e6f84c686952bef16a9 \ - --hash=sha256:b9410c0b6fed4a22554f072a86c361e417f0258838957b78bd063bde2c7f841f \ - --hash=sha256:3d3087e24e354c18fb35c454026af3ed8997cfd4997765266897c68d724e4845 \ - --hash=sha256:89f937b13b8dd17b0099c7c2e22066883c86ca1575a975f754babc8fbf8d69a9 \ - --hash=sha256:a1d7995d1023335e67fb070b2fae6f5968f5be3802b15ad6d79d81ecaa014fe0 \ - --hash=sha256:60759ab15c94dd0e1ed88241fd4fa3312db4e91d2c8f5a2d4cf3863fad83d65b \ - --hash=sha256:125a0e10ddd99a874fd357bfa1b636cd58deb78ba4a30b5ddb09f645c3512e04 \ - --hash=sha256:c26287dfc888cf1e65181f39ea75e11f42ffc4f4529e5bd19add57ad458996e2 \ - --hash=sha256:7199109fa46277be503393be9250b983f325880766f847885607d9b13848f257 \ - --hash=sha256:72251e43ac426ff98ea802a931922c79b8d7596480300eb9f1b1e45e0543571e \ - --hash=sha256:c91ec9569facd4757ade0888371eced2ecf49e7982ce5634cc2cf4e7331a4b14 \ - --hash=sha256:13adf545732bb23a796914fe5f891a12bd74cf3d2986eed7b7eba2941eea1590 \ - --hash=sha256:104f5e90b143dbf298361a99ac1af4cf59131218a045ebf4ee5990b83cff5fab \ - --hash=sha256:89e5336f2bec0c726ac7e7cdae181b325a9c0ee24e604704ed830d241c5e47ff \ - --hash=sha256:032be656d89bbf786d743fee11d01ef318b0781281241997558fa7950028dd29 \ - --hash=sha256:66b467adfcf628f66ea4ac6430ded0614f5cc06ba530d09571ea404789064adc \ - --hash=sha256:12e4ba5c6420917571f1a5becc9338abbde71dd811ce40b37ba62dec7b39af6d \ - --hash=sha256:9c94cab5054bad82a70b2e77741271790304651d584e2cdfe2041488e753863b \ - --hash=sha256:9eb551d122fadca7774b97db8a112b77231dcccda8e91a5bc99e79890797175e \ - --hash=sha256:3bc63486a870294683980d76ec1e3efc786295ae00128f9ea38e2c6e74d5a60a -packaging==20.9; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:67714da7f7bc052e064859c05c595155bd1ee9f69f76557e21f051443c20947a \ - --hash=sha256:5b327ac1320dc863dca72f4514ecc086f31186744b84a230374cc1fd776feae5 -pandocfilters==1.4.3; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.6" \ - --hash=sha256:bc63fbb50534b4b1f8ebe1860889289e8af94a23bff7445259592df25a3906eb -parso==0.8.1; python_version >= "3.7" \ - --hash=sha256:15b00182f472319383252c18d5913b69269590616c947747bc50bf4ac768f410 \ - --hash=sha256:8519430ad07087d4c997fda3a7918f7cfa27cb58972a8c89c2a0295a1c940e9e -pathspec==0.8.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:aa0cb481c4041bf52ffa7b0d8fa6cd3e88a2ca4879c533c9153882ee2556790d \ - --hash=sha256:86379d6b86d75816baba717e64b1a3a3469deb93bb76d613c9ce79edc5cb68fd -pexpect==4.8.0; sys_platform != "win32" and python_version >= "3.7" \ - --hash=sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937 \ - --hash=sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c -pickleshare==0.7.5; python_version >= "3.7" \ - --hash=sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56 \ - --hash=sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca -pillow==8.1.2; python_version >= "3.7" \ - --hash=sha256:5cf03b9534aca63b192856aa601c68d0764810857786ea5da652581f3a44c2b0 \ - --hash=sha256:f91b50ad88048d795c0ad004abbe1390aa1882073b1dca10bfd55d0b8cf18ec5 \ - --hash=sha256:5762ebb4436f46b566fc6351d67a9b5386b5e5de4e58fdaa18a1c83e0e20f1a8 \ - --hash=sha256:e2cd8ac157c1e5ae88b6dd790648ee5d2777e76f1e5c7d184eaddb2938594f34 \ - --hash=sha256:72027ebf682abc9bafd93b43edc44279f641e8996fb2945104471419113cfc71 \ - --hash=sha256:d1d6bca39bb6dd94fba23cdb3eeaea5e30c7717c5343004d900e2a63b132c341 \ - --hash=sha256:90882c6f084ef68b71bba190209a734bf90abb82ab5e8f64444c71d5974008c6 \ - --hash=sha256:89e4c757a91b8c55d97c91fa09c69b3677c227b942fa749e9a66eef602f59c28 \ - --hash=sha256:8c4e32218c764bc27fe49b7328195579581aa419920edcc321c4cb877c65258d \ - --hash=sha256:a01da2c266d9868c4f91a9c6faf47a251f23b9a862dce81d2ff583135206f5be \ - --hash=sha256:30d33a1a6400132e6f521640dd3f64578ac9bfb79a619416d7e8802b4ce1dd55 \ - --hash=sha256:71b01ee69e7df527439d7752a2ce8fb89e19a32df484a308eca3e81f673d3a03 \ - --hash=sha256:5a2d957eb4aba9d48170b8fe6538ec1fbc2119ffe6373782c03d8acad3323f2e \ - --hash=sha256:87f42c976f91ca2fc21a3293e25bd3cd895918597db1b95b93cbd949f7d019ce \ - --hash=sha256:15306d71a1e96d7e271fd2a0737038b5a92ca2978d2e38b6ced7966583e3d5af \ - --hash=sha256:71f31ee4df3d5e0b366dd362007740106d3210fb6a56ec4b581a5324ba254f06 \ - --hash=sha256:98afcac3205d31ab6a10c5006b0cf040d0026a68ec051edd3517b776c1d78b09 \ - --hash=sha256:328240f7dddf77783e72d5ed79899a6b48bc6681f8d1f6001f55933cb4905060 \ - --hash=sha256:bead24c0ae3f1f6afcb915a057943ccf65fc755d11a1410a909c1fefb6c06ad1 \ - --hash=sha256:81b3716cc9744ffdf76b39afb6247eae754186838cedad0b0ac63b2571253fe6 \ - --hash=sha256:63cd413ac52ee3f67057223d363f4f82ce966e64906aea046daf46695e3c8238 \ - --hash=sha256:8565355a29655b28fdc2c666fd9a3890fe5edc6639d128814fafecfae2d70910 \ - --hash=sha256:1940fc4d361f9cc7e558d6f56ff38d7351b53052fd7911f4b60cd7bc091ea3b1 \ - --hash=sha256:46c2bcf8e1e75d154e78417b3e3c64e96def738c2a25435e74909e127a8cba5e \ - --hash=sha256:aeab4cd016e11e7aa5cfc49dcff8e51561fa64818a0be86efa82c7038e9369d0 \ - --hash=sha256:74cd9aa648ed6dd25e572453eb09b08817a1e3d9f8d1bd4d8403d99e42ea790b \ - --hash=sha256:e5739ae63636a52b706a0facec77b2b58e485637e1638202556156e424a02dc2 \ - --hash=sha256:903293320efe2466c1ab3509a33d6b866dc850cfd0c5d9cc92632014cec185fb \ - --hash=sha256:5daba2b40782c1c5157a788ec4454067c6616f5a0c1b70e26ac326a880c2d328 \ - --hash=sha256:1f93f2fe211f1ef75e6f589327f4d4f8545d5c8e826231b042b483d8383e8a7c \ - --hash=sha256:6efac40344d8f668b6c4533ae02a48d52fd852ef0654cc6f19f6ac146399c733 \ - --hash=sha256:f36c3ff63d6fc509ce599a2f5b0d0732189eed653420e7294c039d342c6e204a \ - --hash=sha256:b07c660e014852d98a00a91adfbe25033898a9d90a8f39beb2437d22a203fc44 -pluggy==0.13.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:966c145cd83c96502c3c3868f50408687b38434af77734af1e9ca461a4081d2d \ - --hash=sha256:15b2acde666561e1298d71b523007ed7364de07029219b604cf808bfa1c765b0 -pre-commit==2.11.1; python_full_version >= "3.6.1" \ - --hash=sha256:94c82f1bf5899d56edb1d926732f4e75a7df29a0c8c092559c77420c9d62428b \ - --hash=sha256:de55c5c72ce80d79106e48beb1b54104d16495ce7f95b0c7b13d4784193a00af -prometheus-client==0.9.0; python_version >= "3.6" \ - --hash=sha256:b08c34c328e1bf5961f0b4352668e6c8f145b4a087e09b7296ef62cbe4693d35 \ - --hash=sha256:9da7b32f02439d8c04f7777021c304ed51d9ec180604700c1ba72a4d44dceb03 -prompt-toolkit==3.0.17; python_full_version >= "3.6.1" and python_version >= "3.7" \ - --hash=sha256:4cea7d09e46723885cb8bc54678175453e5071e9449821dce6f017b1d1fbfc1a \ - --hash=sha256:9397a7162cf45449147ad6042fa37983a081b8a73363a5253dd4072666333137 -ptyprocess==0.7.0; sys_platform != "win32" and python_version >= "3.7" and os_name != "nt" \ - --hash=sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35 \ - --hash=sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220 -py==1.10.0; python_version >= "3.6" and python_full_version < "3.0.0" and implementation_name == "pypy" or python_full_version >= "3.5.0" and python_version >= "3.6" and implementation_name == "pypy" \ - --hash=sha256:3b80836aa6d1feeaa108e046da6423ab8f6ceda6468545ae8d02d9d58d18818a \ - --hash=sha256:21b81bda15b66ef5e1a777a21c4dcd9c20ad3efd0b3f817e7a809035269e1bd3 -pybind11==2.6.2; (python_version >= "2.7" and python_version < "3.0") or (python_version > "3.0" and python_version < "3.1") or (python_version > "3.1" and python_version < "3.2") or (python_version > "3.2" and python_version < "3.3") or (python_version > "3.3" and python_version < "3.4") or (python_version > "3.4") \ - --hash=sha256:2d8aebe1709bc367e34e3b23d8eccbf3f387ee9d5640548c6260d33b59f02405 \ - --hash=sha256:d0e0aed9279656f21501243b707eb6e3b951e89e10c3271dedf3ae41c365e5ed -pycodestyle==2.7.0; python_version >= "3.4" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.4" \ - --hash=sha256:514f76d918fcc0b55c6680472f0a37970994e07bbb80725808c17089be302068 \ - --hash=sha256:c389c1d06bf7904078ca03399a4816f974a1d590090fecea0c63ec26ebaf1cef -pycparser==2.20; python_version >= "2.7" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" \ - --hash=sha256:7582ad22678f0fcd81102833f60ef8d0e57288b6b5fb00323d101be910e35705 \ - --hash=sha256:2d475327684562c3a96cc71adf7dc8c4f0565175cf86b6d7a404ff4c771f15f0 -pyerfa==1.7.2; python_version >= "3.7" \ - --hash=sha256:8609be0e659c99fde396b723bbbae9d5074deb0afeba5736c42591877ec01115 \ - --hash=sha256:f0f440d352e7a16c8ca96c9eb28cc70f8f280b93a7834ff4bca92dfc41ae3427 \ - --hash=sha256:152cea1d8feccc098ba762e47a097da0190a46452845f29de5d4494ee5461a0a \ - --hash=sha256:9cb49956dc3859f42229869dc011b38550d34a9922666f540ef474c3f90930eb \ - --hash=sha256:2ffb92d6dd0b951de93e74967675c0acc8eb9f8df75b66492bbe57b83bfed10e \ - --hash=sha256:d32835fc2ddf67de6c2d0f07274cdbff9fb74ee6992b8046d91a6cbba5a999c2 \ - --hash=sha256:317fb9ce3e486b51470854e6656cfdf0cd380173b4ac9965f0e16a52b7452d3e \ - --hash=sha256:b44306c4f8126e05fff84e993e41f717b7490796e27a8ed2af66fd08d3d448e4 \ - --hash=sha256:e2357dc8582493ad0537ed39be5a493457992c043ec788829dc41d4b3d2f3349 \ - --hash=sha256:9a1a1ec5977f246613adcb6b302a768fd05c03f330502dde2c422fb5e36685c3 \ - --hash=sha256:6bb62da1b1ab7a80059340d72dd22cacbff437150feb824d91462e259bae8b58 \ - --hash=sha256:a4282afa9991deba2b26d97aca3c06450c74cf30e5a6b0a38118fc6f8b3f3e58 \ - --hash=sha256:e7dd0dfb1483302315c37b9bd0e0f05a1c5a7c96982fb111547272b030a8b0a9 \ - --hash=sha256:6906b95a752c33da9d717c60bdcfc0004548e6b3f4d2d751aa8ee262aa6b7c78 \ - --hash=sha256:35a7a63d995395d52eebcdb472e3ac1987164c95dd4acc3c3815a0e9cab2353d \ - --hash=sha256:f6a4fc532b9023ebeb0ecf05ba92cc340fe0dd578ca8a57644c359ae49a7a32e \ - --hash=sha256:ce28d076aad6cc173a5f7cdaaa023c0f893d6e3bdae4d47ce26d787df4603a17 \ - --hash=sha256:1067401b4c1e3bd389f5c988a4e53a7aa8d21062d4cae480417f8b63cd17b8d5 \ - --hash=sha256:d120b34e9fc055108f636cce8e9dd0b23294b7266c61587bbaee15a2d3e3b956 \ - --hash=sha256:252163a61c33a9d2f1290a9b41f47a80cfe19414af866371f952e67aa8489cf5 \ - --hash=sha256:94c405c00de83bea864e3d01d39b4b4b8bb4ccc85e8306f4ded0fdc960f2d9f3 \ - --hash=sha256:e75a7a5799e4ad187b77f2afd5ca39116ba00f0df109012f5ac7ad4279165495 \ - --hash=sha256:75a39f680efcdb7ea2fc21731723d91c0c134403cf57954f1200a9a4272a6524 \ - --hash=sha256:32326d2cb8333585c6d9aa804d1f673d98c449f864a377dbc1d246b207bf860c \ - --hash=sha256:ba8765e4dc7bf36fd4851d7217ad1417f57ec88670a5857b3e32ae1aa8d0eb0f \ - --hash=sha256:9e5441baa3100bd04691a935d11c5090dc811313002a7a117cc239d9e6c1f6f2 \ - --hash=sha256:bd2186f2e162e1ed2bbbb4358a87e9421dd587000a6c664dc8fbec8f25464e19 \ - --hash=sha256:a0742218178e01669ca56e67b6877115a0773fa1960edefbe24813fe197a8e08 \ - --hash=sha256:31776213ec36e6bb5382b526be02e417b8697d791c6837199342c19e7dabe8e8 -pyflakes==2.3.0; python_version >= "3.4" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.4" \ - --hash=sha256:910208209dcea632721cb58363d0f72913d9e8cf64dc6f8ae2e02a3609aba40d \ - --hash=sha256:e59fd8e750e588358f1b8885e5a4751203a0516e0ee6d34811089ac294c8806f -pygments==2.8.1; python_version >= "3.7" \ - --hash=sha256:534ef71d539ae97d4c3a4cf7d6f110f214b0e687e92f9cb9d2a3b0d3101289c8 \ - --hash=sha256:2656e1a6edcdabf4275f9a3640db59fd5de107d88e8663c5d4e9a0fa62f77f94 -pyparsing==2.4.7; python_version >= "3.7" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.7" \ - --hash=sha256:ef9d7589ef3c200abe66653d3f1ab1033c3c419ae9b9bdb1240a85b024efc88b \ - --hash=sha256:c203ec8783bf771a155b207279b9bccb8dea02d8f0c9e5f8ead507bc3246ecc1 -pyrsistent==0.17.3; python_version >= "3.6" \ - --hash=sha256:2e636185d9eb976a18a8a8e96efce62f2905fea90041958d8cc2a189756ebf3e -pytest-cov==2.11.1; (python_version >= "2.7" and python_full_version < "3.0.0") or (python_full_version >= "3.5.0") \ - --hash=sha256:359952d9d39b9f822d9d29324483e7ba04a3a17dd7d05aa6beb7ea01e359e5f7 \ - --hash=sha256:bdb9fdb0b85a7cc825269a4c56b48ccaa5c7e365054b6038772c32ddcdc969da -pytest==6.2.2; python_version >= "3.6" \ - --hash=sha256:b574b57423e818210672e07ca1fa90aaf194a4f63f3ab909a2c67ebb22913839 \ - --hash=sha256:9d1edf9e7d0b84d72ea3dbcdfd22b35fb543a5e8f2a60092dd578936bf63d7f9 -python-dateutil==2.8.1; python_version >= "3.7" and python_full_version < "3.0.0" or python_full_version >= "3.3.0" and python_version >= "3.7" \ - --hash=sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c \ - --hash=sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a -pytz==2021.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.6" \ - --hash=sha256:eb10ce3e7736052ed3623d49975ce333bcd712c7bb19a58b9e2089d4057d0798 \ - --hash=sha256:83a4a90894bf38e243cf052c8b58f381bfe9a7a483f6a9cab140bc7f702ac4da -pywavelets==1.1.1; python_version >= "3.7" \ - --hash=sha256:35959c041ec014648575085a97b498eafbbaa824f86f6e4a59bfdef8a3fe6308 \ - --hash=sha256:55e39ec848ceec13c9fa1598253ae9dd5c31d09dfd48059462860d2b908fb224 \ - --hash=sha256:c06d2e340c7bf8b9ec71da2284beab8519a3908eab031f4ea126e8ccfc3fd567 \ - --hash=sha256:be105382961745f88d8196bba5a69ee2c4455d87ad2a2e5d1eed6bd7fda4d3fd \ - --hash=sha256:076ca8907001fdfe4205484f719d12b4a0262dfe6652fa1cfc3c5c362d14dc84 \ - --hash=sha256:7947e51ca05489b85928af52a34fe67022ab5b81d4ae32a4109a99e883a0635e \ - --hash=sha256:9e2528823ccf5a0a1d23262dfefe5034dce89cd84e4e124dc553dfcdf63ebb92 \ - --hash=sha256:80b924edbc012ded8aa8b91cb2fd6207fb1a9a3a377beb4049b8a07445cec6f0 \ - --hash=sha256:c2a799e79cee81a862216c47e5623c97b95f1abee8dd1f9eed736df23fb653fb \ - --hash=sha256:d510aef84d9852653d079c84f2f81a82d5d09815e625f35c95714e7364570ad4 \ - --hash=sha256:889d4c5c5205a9c90118c1980df526857929841df33e4cd1ff1eff77c6817a65 \ - --hash=sha256:68b5c33741d26c827074b3d8f0251de1c3019bb9567b8d303eb093c822ce28f1 \ - --hash=sha256:18a51b3f9416a2ae6e9a35c4af32cf520dd7895f2b69714f4aa2f4342fca47f9 \ - --hash=sha256:cfe79844526dd92e3ecc9490b5031fca5f8ab607e1e858feba232b1b788ff0ea \ - --hash=sha256:2f7429eeb5bf9c7068002d0d7f094ed654c77a70ce5e6198737fd68ab85f8311 \ - --hash=sha256:720dbcdd3d91c6dfead79c80bf8b00a1d8aa4e5d551dc528c6d5151e4efc3403 \ - --hash=sha256:bc5e87b72371da87c9bebc68e54882aada9c3114e640de180f62d5da95749cd3 \ - --hash=sha256:98b2669c5af842a70cfab33a7043fcb5e7535a690a00cd251b44c9be0be418e5 \ - --hash=sha256:e02a0558e0c2ac8b8bbe6a6ac18c136767ec56b96a321e0dfde2173adfa5a504 \ - --hash=sha256:6162dc0ae04669ea04b4b51420777b9ea2d30b0a9d02901b2a3b4d61d159c2e9 \ - --hash=sha256:39c74740718e420d38c78ca4498568fa57976d78d5096277358e0fa9629a7aea \ - --hash=sha256:79f5b54f9dc353e5ee47f0c3f02bebd2c899d49780633aa771fed43fa20b3149 \ - --hash=sha256:935ff247b8b78bdf77647fee962b1cc208c51a7b229db30b9ba5f6da3e675178 \ - --hash=sha256:6ebfefebb5c6494a3af41ad8c60248a95da267a24b79ed143723d4502b1fe4d7 \ - --hash=sha256:6bc78fb9c42a716309b4ace56f51965d8b5662c3ba19d4591749f31773db1125 \ - --hash=sha256:411e17ca6ed8cf5e18a7ca5ee06a91c25800cc6c58c77986202abf98d749273a \ - --hash=sha256:83c5e3eb78ce111c2f0b45f46106cc697c3cb6c4e5f51308e1f81b512c70c8fb \ - --hash=sha256:2b634a54241c190ee989a4af87669d377b37c91bcc9cf0efe33c10ff847f7841 \ - --hash=sha256:732bab78435c48be5d6bc75486ef629d7c8f112e07b313bf1f1a2220ab437277 \ - --hash=sha256:1a64b40f6acb4ffbaccce0545d7fc641744f95351f62e4c6aaa40549326008c9 -pywin32==300; sys_platform == "win32" and python_version >= "3.6" \ - --hash=sha256:1c204a81daed2089e55d11eefa4826c05e604d27fe2be40b6bf8db7b6a39da63 \ - --hash=sha256:350c5644775736351b77ba68da09a39c760d75d2467ecec37bd3c36a94fbed64 \ - --hash=sha256:a3b4c48c852d4107e8a8ec980b76c94ce596ea66d60f7a697582ea9dce7e0db7 \ - --hash=sha256:27a30b887afbf05a9cbb05e3ffd43104a9b71ce292f64a635389dbad0ed1cd85 \ - --hash=sha256:d7e8c7efc221f10d6400c19c32a031add1c4a58733298c09216f57b4fde110dc \ - --hash=sha256:8151e4d7a19262d6694162d6da85d99a16f8b908949797fd99c83a0bfaf5807d \ - --hash=sha256:fbb3b1b0fbd0b4fc2a3d1d81fe0783e30062c1abed1d17c32b7879d55858cfae \ - --hash=sha256:60a8fa361091b2eea27f15718f8eb7f9297e8d51b54dbc4f55f3d238093d5190 \ - --hash=sha256:638b68eea5cfc8def537e43e9554747f8dee786b090e47ead94bfdafdb0f2f50 \ - --hash=sha256:b1609ce9bd5c411b81f941b246d683d6508992093203d4eb7f278f4ed1085c3f -pywinpty==0.5.7; os_name == "nt" and python_version >= "3.6" \ - --hash=sha256:b358cb552c0f6baf790de375fab96524a0498c9df83489b8c23f7f08795e966b \ - --hash=sha256:1e525a4de05e72016a7af27836d512db67d06a015aeaf2fa0180f8e6a039b3c2 \ - --hash=sha256:2740eeeb59297593a0d3f762269b01d0285c1b829d6827445fcd348fb47f7e70 \ - --hash=sha256:33df97f79843b2b8b8bc5c7aaf54adec08cc1bae94ee99dfb1a93c7a67704d95 \ - --hash=sha256:e854211df55d107f0edfda8a80b39dfc87015bef52a8fe6594eb379240d81df2 \ - --hash=sha256:dbd838de92de1d4ebf0dce9d4d5e4fc38d0b7b1de837947a18b57a882f219139 \ - --hash=sha256:5fb2c6c6819491b216f78acc2c521b9df21e0f53b9a399d58a5c151a3c4e2a2d \ - --hash=sha256:dd22c8efacf600730abe4a46c1388355ce0d4ab75dc79b15d23a7bd87bf05b48 \ - --hash=sha256:8fc5019ff3efb4f13708bd3b5ad327589c1a554cb516d792527361525a7cb78c \ - --hash=sha256:2d7e9c881638a72ffdca3f5417dd1563b60f603e1b43e5895674c2a1b01f95a0 -pyyaml==5.4.1; python_full_version >= "3.6.1" \ - --hash=sha256:3b2b1824fe7112845700f815ff6a489360226a5609b96ec2190a45e62a9fc922 \ - --hash=sha256:129def1b7c1bf22faffd67b8f3724645203b79d8f4cc81f674654d9902cb4393 \ - --hash=sha256:4465124ef1b18d9ace298060f4eccc64b0850899ac4ac53294547536533800c8 \ - --hash=sha256:bb4191dfc9306777bc594117aee052446b3fa88737cd13b7188d0e7aa8162185 \ - --hash=sha256:6c78645d400265a062508ae399b60b8c167bf003db364ecb26dcab2bda048253 \ - --hash=sha256:4e0583d24c881e14342eaf4ec5fbc97f934b999a6828693a99157fde912540cc \ - --hash=sha256:72a01f726a9c7851ca9bfad6fd09ca4e090a023c00945ea05ba1638c09dc3347 \ - --hash=sha256:895f61ef02e8fed38159bb70f7e100e00f471eae2bc838cd0f4ebb21e28f8541 \ - --hash=sha256:3bd0e463264cf257d1ffd2e40223b197271046d09dadf73a0fe82b9c1fc385a5 \ - --hash=sha256:e4fac90784481d221a8e4b1162afa7c47ed953be40d31ab4629ae917510051df \ - --hash=sha256:5accb17103e43963b80e6f837831f38d314a0495500067cb25afab2e8d7a4018 \ - --hash=sha256:e1d4970ea66be07ae37a3c2e48b5ec63f7ba6804bdddfdbd3cfd954d25a82e63 \ - --hash=sha256:cb333c16912324fd5f769fff6bc5de372e9e7a202247b48870bc251ed40239aa \ - --hash=sha256:fe69978f3f768926cfa37b867e3843918e012cf83f680806599ddce33c2c68b0 \ - --hash=sha256:dd5de0646207f053eb0d6c74ae45ba98c3395a571a2891858e87df7c9b9bd51b \ - --hash=sha256:08682f6b72c722394747bddaf0aa62277e02557c0fd1c42cb853016a38f8dedf \ - --hash=sha256:d2d9808ea7b4af864f35ea216be506ecec180628aced0704e34aca0b040ffe46 \ - --hash=sha256:8c1be557ee92a20f184922c7b6424e8ab6691788e6d86137c5d93c1a6ec1b8fb \ - --hash=sha256:fd7f6999a8070df521b6384004ef42833b9bd62cfee11a09bda1079b4b704247 \ - --hash=sha256:bfb51918d4ff3d77c1c856a9699f8492c612cde32fd3bcd344af9be34999bfdc \ - --hash=sha256:fa5ae20527d8e831e8230cbffd9f8fe952815b2b7dae6ffec25318803a7528fc \ - --hash=sha256:0f5f5786c0e09baddcd8b4b45f20a7b5d61a7e7e99846e3c799b05c7c53fa696 \ - --hash=sha256:294db365efa064d00b8d1ef65d8ea2c3426ac366c0c4368d930bf1c5fb497f77 \ - --hash=sha256:74c1485f7707cf707a7aef42ef6322b8f97921bd89be2ab6317fd782c2d53183 \ - --hash=sha256:d483ad4e639292c90170eb6f7783ad19490e7a8defb3e46f97dfe4bacae89122 \ - --hash=sha256:fdc842473cd33f45ff6bce46aea678a54e3d21f1b61a7750ce3c498eedfe25d6 \ - --hash=sha256:49d4cdd9065b9b6e206d0595fee27a96b5dd22618e7520c33204a4a3239d5b10 \ - --hash=sha256:c20cfa2d49991c8b4147af39859b167664f2ad4561704ee74c1de03318e898db \ - --hash=sha256:607774cbba28732bfa802b54baa7484215f530991055bb562efbed5b2f20a45e -pyzmq==22.0.3; python_version >= "3.6" \ - --hash=sha256:c0cde362075ee8f3d2b0353b283e203c2200243b5a15d5c5c03b78112a17e7d4 \ - --hash=sha256:ff1ea14075bbddd6f29bf6beb8a46d0db779bcec6b9820909584081ec119f8fd \ - --hash=sha256:26380487eae4034d6c2a3fb8d0f2dff6dd0d9dd711894e8d25aa2d1938950a33 \ - --hash=sha256:3e29f9cf85a40d521d048b55c63f59d6c772ac1c4bf51cdfc23b62a62e377c33 \ - --hash=sha256:4f34a173f813b38b83f058e267e30465ed64b22cd0cf6bad21148d3fa718f9bb \ - --hash=sha256:30df70f81fe210506aa354d7fd486a39b87d9f7f24c3d3f4f698ec5d96b8c084 \ - --hash=sha256:7026f0353977431fc884abd4ac28268894bd1a780ba84bb266d470b0ec26d2ed \ - --hash=sha256:6d4163704201fff0f3ab0cd5d7a0ea1514ecfffd3926d62ec7e740a04d2012c7 \ - --hash=sha256:763c175294d861869f18eb42901d500eda7d3fa4565f160b3b2fd2678ea0ebab \ - --hash=sha256:61e4bb6cd60caf1abcd796c3f48395e22c5b486eeca6f3a8797975c57d94b03e \ - --hash=sha256:b25e5d339550a850f7e919fe8cb4c8eabe4c917613db48dab3df19bfb9a28969 \ - --hash=sha256:3ef50d74469b03725d781a2a03c57537d86847ccde587130fe35caafea8f75c6 \ - --hash=sha256:60e63577b85055e4cc43892fecd877b86695ee3ef12d5d10a3c5d6e77a7cc1a3 \ - --hash=sha256:f5831eff6b125992ec65d973f5151c48003b6754030094723ac4c6e80a97c8c4 \ - --hash=sha256:9221783dacb419604d5345d0e097bddef4459a9a95322de6c306bf1d9896559f \ - --hash=sha256:b62ea18c0458a65ccd5be90f276f7a5a3f26a6dea0066d948ce2fa896051420f \ - --hash=sha256:81e7df0da456206201e226491aa1fc449da85328bf33bbeec2c03bb3a9f18324 \ - --hash=sha256:f52070871a0fd90a99130babf21f8af192304ec1e995bec2a9533efc21ea4452 \ - --hash=sha256:c5e29fe4678f97ce429f076a2a049a3d0b2660ada8f2c621e5dc9939426056dd \ - --hash=sha256:d18ddc6741b51f3985978f2fda57ddcdae359662d7a6b395bc8ff2292fca14bd \ - --hash=sha256:4231943514812dfb74f44eadcf85e8dd8cf302b4d0bce450ce1357cac88dbfdc \ - --hash=sha256:23a74de4b43c05c3044aeba0d1f3970def8f916151a712a3ac1e5cd9c0bc2902 \ - --hash=sha256:532af3e6dddea62d9c49062ece5add998c9823c2419da943cf95589f56737de0 \ - --hash=sha256:33acd2b9790818b9d00526135acf12790649d8d34b2b04d64558b469c9d86820 \ - --hash=sha256:a558c5bc89d56d7253187dccc4e81b5bb0eac5ae9511eb4951910a1245d04622 \ - --hash=sha256:581787c62eaa0e0db6c5413cedc393ebbadac6ddfd22e1cf9a60da23c4f1a4b2 \ - --hash=sha256:38e3dca75d81bec4f2defa14b0a65b74545812bb519a8e89c8df96bbf4639356 \ - --hash=sha256:2f971431aaebe0a8b54ac018e041c2f0b949a43745444e4dadcc80d0f0ef8457 \ - --hash=sha256:da7d4d4c778c86b60949d17531e60c54ed3726878de8a7f8a6d6e7f8cc8c3205 \ - --hash=sha256:13465c1ff969cab328bc92f7015ce3843f6e35f8871ad79d236e4fbc85dbe4cb \ - --hash=sha256:279cc9b51db48bec2db146f38e336049ac5a59e5f12fb3a8ad864e238c1c62e3 \ - --hash=sha256:f7f63ce127980d40f3e6a5fdb87abf17ce1a7c2bd8bf2c7560e1bbce8ab1f92d -regex==2021.3.17; python_version >= "3.6" \ - --hash=sha256:b97ec5d299c10d96617cc851b2e0f81ba5d9d6248413cd374ef7f3a8871ee4a6 \ - --hash=sha256:cb4ee827857a5ad9b8ae34d3c8cc51151cb4a3fe082c12ec20ec73e63cc7c6f0 \ - --hash=sha256:633497504e2a485a70a3268d4fc403fe3063a50a50eed1039083e9471ad0101c \ - --hash=sha256:a59a2ee329b3de764b21495d78c92ab00b4ea79acef0f7ae8c1067f773570afa \ - --hash=sha256:f85d6f41e34f6a2d1607e312820971872944f1661a73d33e1e82d35ea3305e14 \ - --hash=sha256:4651f839dbde0816798e698626af6a2469eee6d9964824bb5386091255a1694f \ - --hash=sha256:39c44532d0e4f1639a89e52355b949573e1e2c5116106a395642cbbae0ff9bcd \ - --hash=sha256:3d9a7e215e02bd7646a91fb8bcba30bc55fd42a719d6b35cf80e5bae31d9134e \ - --hash=sha256:159fac1a4731409c830d32913f13f68346d6b8e39650ed5d704a9ce2f9ef9cb3 \ - --hash=sha256:13f50969028e81765ed2a1c5fcfdc246c245cf8d47986d5172e82ab1a0c42ee5 \ - --hash=sha256:b9d8d286c53fe0cbc6d20bf3d583cabcd1499d89034524e3b94c93a5ab85ca90 \ - --hash=sha256:201e2619a77b21a7780580ab7b5ce43835e242d3e20fef50f66a8df0542e437f \ - --hash=sha256:d47d359545b0ccad29d572ecd52c9da945de7cd6cf9c0cfcb0269f76d3555689 \ - --hash=sha256:ea2f41445852c660ba7c3ebf7d70b3779b20d9ca8ba54485a17740db49f46932 \ - --hash=sha256:486a5f8e11e1f5bbfcad87f7c7745eb14796642323e7e1829a331f87a713daaa \ - --hash=sha256:18e25e0afe1cf0f62781a150c1454b2113785401ba285c745acf10c8ca8917df \ - --hash=sha256:a2ee026f4156789df8644d23ef423e6194fad0bc53575534101bb1de5d67e8ce \ - --hash=sha256:4c0788010a93ace8a174d73e7c6c9d3e6e3b7ad99a453c8ee8c975ddd9965643 \ - --hash=sha256:575a832e09d237ae5fedb825a7a5bc6a116090dd57d6417d4f3b75121c73e3be \ - --hash=sha256:8e65e3e4c6feadf6770e2ad89ad3deb524bcb03d8dc679f381d0568c024e0deb \ - --hash=sha256:a0df9a0ad2aad49ea3c7f65edd2ffb3d5c59589b85992a6006354f6fb109bb18 \ - --hash=sha256:b98bc9db003f1079caf07b610377ed1ac2e2c11acc2bea4892e28cc5b509d8d5 \ - --hash=sha256:808404898e9a765e4058bf3d7607d0629000e0a14a6782ccbb089296b76fa8fe \ - --hash=sha256:5770a51180d85ea468234bc7987f5597803a4c3d7463e7323322fe4a1b181578 \ - --hash=sha256:976a54d44fd043d958a69b18705a910a8376196c6b6ee5f2596ffc11bff4420d \ - --hash=sha256:63f3ca8451e5ff7133ffbec9eda641aeab2001be1a01878990f6c87e3c44b9d5 \ - --hash=sha256:bcd945175c29a672f13fce13a11893556cd440e37c1b643d6eeab1988c8b209c \ - --hash=sha256:3d9356add82cff75413bec360c1eca3e58db4a9f5dafa1f19650958a81e3249d \ - --hash=sha256:f5d0c921c99297354cecc5a416ee4280bd3f20fd81b9fb671ca6be71499c3fdf \ - --hash=sha256:14de88eda0976020528efc92d0a1f8830e2fb0de2ae6005a6fc4e062553031fa \ - --hash=sha256:4c2e364491406b7888c2ad4428245fc56c327e34a5dfe58fd40df272b3c3dab3 \ - --hash=sha256:8bd4f91f3fb1c9b1380d6894bd5b4a519409135bec14c0c80151e58394a4e88a \ - --hash=sha256:882f53afe31ef0425b405a3f601c0009b44206ea7f55ee1c606aad3cc213a52c \ - --hash=sha256:07ef35301b4484bce843831e7039a84e19d8d33b3f8b2f9aab86c376813d0139 \ - --hash=sha256:360a01b5fa2ad35b3113ae0c07fb544ad180603fa3b1f074f52d98c1096fa15e \ - --hash=sha256:709f65bb2fa9825f09892617d01246002097f8f9b6dde8d1bb4083cf554701ba \ - --hash=sha256:c66221e947d7207457f8b6f42b12f613b09efa9669f65a587a2a71f6a0e4d106 \ - --hash=sha256:c782da0e45aff131f0bed6e66fbcfa589ff2862fc719b83a88640daa01a5aff7 \ - --hash=sha256:dc9963aacb7da5177e40874585d7407c0f93fb9d7518ec58b86e562f633f36cd \ - --hash=sha256:a0d04128e005142260de3733591ddf476e4902c0c23c1af237d9acf3c96e1b38 \ - --hash=sha256:4b8a1fb724904139149a43e172850f35aa6ea97fb0545244dc0b805e0154ed68 -reorder-python-imports==2.4.0; python_full_version >= "3.6.1" \ - --hash=sha256:995a2a93684af31837f30cf2bcddce2e7eb17f0d2d69c9905da103baf8cec42b \ - --hash=sha256:9a9e7774d66e9b410b619f934e8206a63dce5be26bd894f5006eb764bba6a26d -requests==2.25.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:c210084e36a42ae6b9219e00e48287def368a26d03a048ddad7bfee44f75871e \ - --hash=sha256:27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804 -scikit-image==0.18.1; python_version >= "3.7" \ - --hash=sha256:fbb618ca911867bce45574c1639618cdfb5d94e207432b19bc19563d80d2f171 \ - --hash=sha256:1cd05c882ffb2a271a1f20b4afe937d63d55b8753c3d652f11495883a7800ebe \ - --hash=sha256:e972c628ad9ba52c298b032368e29af9bd5eeb81ce33bc2d9b039a81661c99c5 \ - --hash=sha256:1256017c513e8e1b8b9da73e5fd1e605d0077bbbc8e5c8d6c2cab36400131c6c \ - --hash=sha256:ec25e4110951d3a280421bb10dd510a082ba83d86e20d706294faf7899cdb3d5 \ - --hash=sha256:2eea42706a25ae6e0cebaf1914e2ab1c04061b1f3c9966d76025d58a2e9188fc \ - --hash=sha256:76446e2402e64d7dba78eeae8aa86e92a0cafe5b1c9e6235bd8d067471ed2788 \ - --hash=sha256:d5ad4a9b4c9797d4c4c48f45fa224c5ebff22b9b0af636c3ecb8addbb66c21e6 \ - --hash=sha256:23f9178b21c752bfb4e4ea3a3fa0ff79bc5a401bc75ddb4661f2cebd1c2b0e24 \ - --hash=sha256:d746540cafe7776c6d05a0b40ec744bb8d33d1ddc51faba601d26c02593d8bcc \ - --hash=sha256:30447af3f5b7c9491f2d3db5bc275493d1b91bf1dd16b67e2fd79a6bb95d8ee9 \ - --hash=sha256:ae6659b3a8bd4bba7e9dcbfd0064e443b32c7054bf09174749db896730fcf42e \ - --hash=sha256:2c058770c6ad6e0fe6c30f59970c9c65fa740ff014d121d8c341664cd792cf49 \ - --hash=sha256:c700336a7f96109c74154090c5e693693a8e3fa09ed6156a5996cdc9a3bb1534 \ - --hash=sha256:3515b890e771f99bbe1051a0dcfe0fc477da961da933c34f89808a0f1eeb7dc2 \ - --hash=sha256:5f602779258807d03e72c0a439cfb221f647e628be166fb3594397435f13c76b -scipy==1.6.1; python_version >= "3.7" \ - --hash=sha256:a15a1f3fc0abff33e792d6049161b7795909b40b97c6cc2934ed54384017ab76 \ - --hash=sha256:e79570979ccdc3d165456dd62041d9556fb9733b86b4b6d818af7a0afc15f092 \ - --hash=sha256:a423533c55fec61456dedee7b6ee7dce0bb6bfa395424ea374d25afa262be261 \ - --hash=sha256:33d6b7df40d197bdd3049d64e8e680227151673465e5d85723b3b8f6b15a6ced \ - --hash=sha256:6725e3fbb47da428794f243864f2297462e9ee448297c93ed1dcbc44335feb78 \ - --hash=sha256:5fa9c6530b1661f1370bcd332a1e62ca7881785cc0f80c0d559b636567fab63c \ - --hash=sha256:bd50daf727f7c195e26f27467c85ce653d41df4358a25b32434a50d8870fc519 \ - --hash=sha256:f46dd15335e8a320b0fb4685f58b7471702234cba8bb3442b69a3e1dc329c345 \ - --hash=sha256:0e5b0ccf63155d90da576edd2768b66fb276446c371b73841e3503be1d63fb5d \ - --hash=sha256:2481efbb3740977e3c831edfd0bd9867be26387cacf24eb5e366a6a374d3d00d \ - --hash=sha256:68cb4c424112cd4be886b4d979c5497fba190714085f46b8ae67a5e4416c32b4 \ - --hash=sha256:5f331eeed0297232d2e6eea51b54e8278ed8bb10b099f69c44e2558c090d06bf \ - --hash=sha256:0c8a51d33556bf70367452d4d601d1742c0e806cd0194785914daf19775f0e67 \ - --hash=sha256:83bf7c16245c15bc58ee76c5418e46ea1811edcc2e2b03041b804e46084ab627 \ - --hash=sha256:794e768cc5f779736593046c9714e0f3a5940bc6dcc1dba885ad64cbfb28e9f0 \ - --hash=sha256:5da5471aed911fe7e52b86bf9ea32fb55ae93e2f0fac66c32e58897cfb02fa07 \ - --hash=sha256:8e403a337749ed40af60e537cc4d4c03febddcc56cd26e774c9b1b600a70d3e4 \ - --hash=sha256:a5193a098ae9f29af283dcf0041f762601faf2e595c0db1da929875b7570353f \ - --hash=sha256:c4fceb864890b6168e79b0e714c585dbe2fd4222768ee90bc1aa0f8218691b11 -send2trash==1.5.0; python_version >= "3.6" \ - --hash=sha256:f1691922577b6fa12821234aeb57599d887c4900b9ca537948d2dac34aea888b \ - --hash=sha256:60001cc07d707fe247c94f74ca6ac0d3255aabcb930529690897ca2a39db28b2 -sep==1.1.1; python_version >= "3.5" \ - --hash=sha256:2e6e2dceb9da1fd9981edff50d0950b13c234d21ac2750dd81903683e25c0067 \ - --hash=sha256:df544e4b493823070a6c8b0e8a9258d36237683b21c781dfafe89bdf4e3560c8 \ - --hash=sha256:65c0dde0362809c16295eaa321e3542c97089b9752a7575888cf4375a0057ccd \ - --hash=sha256:8c204b7c3def5e1db3fcb58c8c96b8015111b3fd4bc45004ea7076114937db4a \ - --hash=sha256:e98df2c4c04c132c21e5af0e5952428c94e85c93a18c87c6a47961c458145600 \ - --hash=sha256:bd02dd0173c667934154d3dc3bfbcd373ca704f8433bbcda00056d40a64dab81 \ - --hash=sha256:7e28b973a931180f30dc7bfaf1817e3a8db47050d9cc63bfc305cdf3a9c88f1b \ - --hash=sha256:3e09bd623038b9b6eac5f3edf8bfeda12fe5f5bec3e89f3e77181bbdc6d368a5 \ - --hash=sha256:8395a60aa0b98cf6fdb43ae9a1d7289bd70603e69f37c3c80735ebb2c658182c \ - --hash=sha256:941ac18702ae548e31c2cc771fa832d02b8115ca70942c118576313086fb9e6a \ - --hash=sha256:07b66ff14a977e7b79a2ec72ae3b4a14c23a85471d9130a7c17087b8a7956e6c \ - --hash=sha256:6aeddf4d78c199a5bf4394cfbb178d73da06cda6b9127ec554ecf429ddb0a073 \ - --hash=sha256:3108b3b84525a0c6a6edb1373414a636053f852c76b9a5a109f476ef438514d7 \ - --hash=sha256:eb55f27ca61477f1cfc520e667c05746dcb792edf9e853cbfbb2be496b14d79c \ - --hash=sha256:5c2b9b370e1a851dc409022aef2aa573e09b235399a1c73f86654177f244f566 \ - --hash=sha256:c25147856174000966642e54f31802a79c133a705ab9726ba338907eecc97f70 \ - --hash=sha256:ea23c575baccfb68e08ce43022a37a8847d04b9c8464510bc89a63d27ce01366 \ - --hash=sha256:8e32f517d257892a25f80a29a5bb5cff813c888c713c29a82f850c0ce0f6b65f \ - --hash=sha256:e05ea3778ca259769e18fcf2af4df3c863de542bba037bf034498d4b2e2a1843 \ - --hash=sha256:9fefb18d3bb75f9a98e80abe265c16102b77006f10d2422b68028c370826d074 \ - --hash=sha256:c45dd0d2a79518d6daf8276dd8c502f63c640604786a0e24bd44ea2671876345 \ - --hash=sha256:298e6a1496c464bd077377f7c3301b8c5df02e13fce9960cfe35c0842ce2fb7d \ - --hash=sha256:d1fe48180f130e7217ed4416125d75954456dce54792463a42121fc3a5fb8155 \ - --hash=sha256:b086c12190a5129c8b01a2aa5a6a8790e19ceb7cba2610dc0f0d739ad6975676 \ - --hash=sha256:2b55e1ca8fdb983eed7d353db2856f6825100bfe82e242646c0084a74de3c52e \ - --hash=sha256:84b3a4982c88124da9f1a74c874e02d8d11ddc50a4f87bcb598ae449c1939501 \ - --hash=sha256:b583594d8a0750b76959c1df71c739164b4f74c80aebeac7b6cef75802f2ccd9 \ - --hash=sha256:c67eef5eb9710b94a326d4743dee19b50738fed654ccea9c80a39289ef92cca7 \ - --hash=sha256:e4465538898b241facfa52ff5b6c89ef611720d0eb692475dfd93c6fe8576c45 \ - --hash=sha256:ebb64079e836c67b04afdec93abddc1209ac35e6d52c495776d70aa9df9ca3f0 \ - --hash=sha256:9548af5f13ea9bbfc3a76d15d809b7df72c31442f0c47e26daf9052c92c5ad73 -six==1.15.0; python_full_version >= "3.6.1" and python_version >= "3.6" and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6") and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.3.0" and python_version >= "3.6") \ - --hash=sha256:8b74bedcbbbaca38ff6d7491d76f2b06b3592611af620f8426e82dddb04a5ced \ - --hash=sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259 -snowballstemmer==2.1.0; python_version >= "3.6" \ - --hash=sha256:b51b447bea85f9968c13b650126a888aabd4cb4463fca868ec596826325dedc2 \ - --hash=sha256:e997baa4f2e9139951b6f4c631bad912dfd3c792467e2f03d7239464af90e914 -sphinx-rtd-theme==0.4.3 \ - --hash=sha256:00cf895504a7895ee433807c62094cf1e95f065843bf3acd17037c3e9a2becd4 \ - --hash=sha256:728607e34d60456d736cc7991fd236afb828b21b82f956c5ea75f94c8414040a -sphinx==3.5.2; python_version >= "3.5" \ - --hash=sha256:ef64a814576f46ec7de06adf11b433a0d6049be007fefe7fd0d183d28b581fac \ - --hash=sha256:672cfcc24b6b69235c97c750cb190a44ecd72696b4452acaf75c2d9cc78ca5ff -sphinxcontrib-applehelp==1.0.2; python_version >= "3.6" \ - --hash=sha256:a072735ec80e7675e3f432fcae8610ecf509c5f1869d17e2eecff44389cdbc58 \ - --hash=sha256:806111e5e962be97c29ec4c1e7fe277bfd19e9652fb1a4392105b43e01af885a -sphinxcontrib-devhelp==1.0.2; python_version >= "3.6" \ - --hash=sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4 \ - --hash=sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e -sphinxcontrib-htmlhelp==1.0.3; python_version >= "3.6" \ - --hash=sha256:e8f5bb7e31b2dbb25b9cc435c8ab7a79787ebf7f906155729338f3156d93659b \ - --hash=sha256:3c0bc24a2c41e340ac37c85ced6dafc879ab485c095b1d65d2461ac2f7cca86f -sphinxcontrib-jsmath==1.0.1; python_version >= "3.6" \ - --hash=sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8 \ - --hash=sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178 -sphinxcontrib-qthelp==1.0.3; python_version >= "3.6" \ - --hash=sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72 \ - --hash=sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6 -sphinxcontrib-serializinghtml==1.1.4; python_version >= "3.6" \ - --hash=sha256:eaa0eccc86e982a9b939b2b82d12cc5d013385ba5eadcc7e4fed23f4405f77bc \ - --hash=sha256:f242a81d423f59617a8e5cf16f5d4d74e28ee9a66f9e5b637a18082991db5a9a -terminado==0.9.3; python_version >= "3.6" \ - --hash=sha256:430e876ec9d4d93a4fd8a49e82dcfae0c25f846540d0c5ca774b397533e237e8 \ - --hash=sha256:261c0b7825fecf629666e1820b484a5380f7e54d6b8bd889fa482e99dcf9bde4 -testpath==0.4.4; python_version >= "3.6" \ - --hash=sha256:bfcf9411ef4bf3db7579063e0546938b1edda3d69f4e1fb8756991f5951f85d4 \ - --hash=sha256:60e0a3261c149755f4399a1fff7d37523179a70fdc3abdf78de9fc2604aeec7e -tifffile==2021.3.17; python_version >= "3.7" \ - --hash=sha256:f6092aba910ed52b6087877c9a2f604ba67623a8703fa8079929b62992dcc69c \ - --hash=sha256:1b72c92ecd2273e52686c0f8792d1d1c4da4109b241dd1723dfe56ef4d1ad612 -toml==0.10.2; python_full_version >= "3.6.1" and python_version >= "3.6" and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.3.0" and python_version >= "3.6") and (python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6") \ - --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \ - --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f -tornado==6.1; python_version >= "3.6" \ - --hash=sha256:d371e811d6b156d82aa5f9a4e08b58debf97c302a35714f6f45e35139c332e32 \ - --hash=sha256:0d321a39c36e5f2c4ff12b4ed58d41390460f798422c4504e09eb5678e09998c \ - --hash=sha256:9de9e5188a782be6b1ce866e8a51bc76a0fbaa0e16613823fc38e4fc2556ad05 \ - --hash=sha256:61b32d06ae8a036a6607805e6720ef00a3c98207038444ba7fd3d169cd998910 \ - --hash=sha256:3e63498f680547ed24d2c71e6497f24bca791aca2fe116dbc2bd0ac7f191691b \ - --hash=sha256:6c77c9937962577a6a76917845d06af6ab9197702a42e1346d8ae2e76b5e3675 \ - --hash=sha256:6286efab1ed6e74b7028327365cf7346b1d777d63ab30e21a0f4d5b275fc17d5 \ - --hash=sha256:fa2ba70284fa42c2a5ecb35e322e68823288a4251f9ba9cc77be04ae15eada68 \ - --hash=sha256:0a00ff4561e2929a2c37ce706cb8233b7907e0cdc22eab98888aca5dd3775feb \ - --hash=sha256:748290bf9112b581c525e6e6d3820621ff020ed95af6f17fedef416b27ed564c \ - --hash=sha256:e385b637ac3acaae8022e7e47dfa7b83d3620e432e3ecb9a3f7f58f150e50921 \ - --hash=sha256:25ad220258349a12ae87ede08a7b04aca51237721f63b1808d39bdb4b2164558 \ - --hash=sha256:65d98939f1a2e74b58839f8c4dab3b6b3c1ce84972ae712be02845e65391ac7c \ - --hash=sha256:e519d64089b0876c7b467274468709dadf11e41d65f63bba207e04217f47c085 \ - --hash=sha256:b87936fd2c317b6ee08a5741ea06b9d11a6074ef4cc42e031bc6403f82a32575 \ - --hash=sha256:cc0ee35043162abbf717b7df924597ade8e5395e7b66d18270116f8745ceb795 \ - --hash=sha256:7250a3fa399f08ec9cb3f7b1b987955d17e044f1ade821b32e5f435130250d7f \ - --hash=sha256:ed3ad863b1b40cd1d4bd21e7498329ccaece75db5a5bf58cd3c9f130843e7102 \ - --hash=sha256:dcef026f608f678c118779cd6591c8af6e9b4155c44e0d1bc0c87c036fb8c8c4 \ - --hash=sha256:70dec29e8ac485dbf57481baee40781c63e381bebea080991893cd297742b8fd \ - --hash=sha256:d3f7594930c423fd9f5d1a76bee85a2c36fd8b4b16921cae7e965f22575e9c01 \ - --hash=sha256:3447475585bae2e77ecb832fc0300c3695516a47d46cefa0528181a34c5b9d3d \ - --hash=sha256:e7229e60ac41a1202444497ddde70a48d33909e484f96eb0da9baf8dc68541df \ - --hash=sha256:cb5ec8eead331e3bb4ce8066cf06d2dfef1bfb1b2a73082dfe8a161301b76e37 \ - --hash=sha256:20241b3cb4f425e971cb0a8e4ffc9b0a861530ae3c52f2b0434e6c1b57e9fd95 \ - --hash=sha256:c77da1263aa361938476f04c4b6c8916001b90b2c2fdd92d8d535e1af48fba5a \ - --hash=sha256:fba85b6cd9c39be262fcd23865652920832b61583de2a2ca907dbd8e8a8c81e5 \ - --hash=sha256:1e8225a1070cd8eec59a996c43229fe8f95689cb16e552d130b9793cb570a288 \ - --hash=sha256:d14d30e7f46a0476efb0deb5b61343b1526f73ebb5ed84f23dc794bdb88f9d9f \ - --hash=sha256:8f959b26f2634a091bb42241c3ed8d3cedb506e7c27b8dd5c7b9f745318ddbb6 \ - --hash=sha256:34ca2dac9e4d7afb0bed4677512e36a52f09caa6fded70b4e3e1c89dbd92c326 \ - --hash=sha256:6196a5c39286cc37c024cd78834fb9345e464525d8991c21e908cc046d1cc02c \ - --hash=sha256:f0ba29bafd8e7e22920567ce0d232c26d4d47c8b5cf4ed7b562b5db39fa199c5 \ - --hash=sha256:33892118b165401f291070100d6d09359ca74addda679b60390b09f8ef325ffe \ - --hash=sha256:7da13da6f985aab7f6f28debab00c67ff9cbacd588e8477034c0652ac141feea \ - --hash=sha256:e0791ac58d91ac58f694d8d2957884df8e4e2f6687cdf367ef7eb7497f79eaa2 \ - --hash=sha256:66324e4e1beede9ac79e60f88de548da58b1f8ab4b2f1354d8375774f997e6c0 \ - --hash=sha256:a48900ecea1cbb71b8c71c620dee15b62f85f7c14189bdeee54966fbd9a0c5bd \ - --hash=sha256:d3d20ea5782ba63ed13bc2b8c291a053c8d807a8fa927d941bd718468f7b950c \ - --hash=sha256:548430be2740e327b3fe0201abe471f314741efcb0067ec4f2d7dcfb4825f3e4 \ - --hash=sha256:33c6e81d7bd55b468d2e793517c909b139960b6c790a60b7991b9b6b76fb9791 -traitlets==5.0.5; python_full_version >= "3.6.1" and python_version >= "3.7" \ - --hash=sha256:69ff3f9d5351f31a7ad80443c2674b7099df13cc41fc5fa6e2f6d3b0330b0426 \ - --hash=sha256:178f4ce988f69189f7e523337a3e11d91c786ded9360174a3d9ca83e79bc5396 -typed-ast==1.4.2; python_version >= "3.6" \ - --hash=sha256:7703620125e4fb79b64aa52427ec192822e9f45d37d4b6625ab37ef403e1df70 \ - --hash=sha256:c9aadc4924d4b5799112837b226160428524a9a45f830e0d0f184b19e4090487 \ - --hash=sha256:9ec45db0c766f196ae629e509f059ff05fc3148f9ffd28f3cfe75d4afb485412 \ - --hash=sha256:85f95aa97a35bdb2f2f7d10ec5bbdac0aeb9dafdaf88e17492da0504de2e6400 \ - --hash=sha256:9044ef2df88d7f33692ae3f18d3be63dec69c4fb1b5a4a9ac950f9b4ba571606 \ - --hash=sha256:c1c876fd795b36126f773db9cbb393f19808edd2637e00fd6caba0e25f2c7b64 \ - --hash=sha256:5dcfc2e264bd8a1db8b11a892bd1647154ce03eeba94b461effe68790d8b8e07 \ - --hash=sha256:8db0e856712f79c45956da0c9a40ca4246abc3485ae0d7ecc86a20f5e4c09abc \ - --hash=sha256:d003156bb6a59cda9050e983441b7fa2487f7800d76bdc065566b7d728b4581a \ - --hash=sha256:4c790331247081ea7c632a76d5b2a265e6d325ecd3179d06e9cf8d46d90dd151 \ - --hash=sha256:d175297e9533d8d37437abc14e8a83cbc68af93cc9c1c59c2c292ec59a0697a3 \ - --hash=sha256:cf54cfa843f297991b7388c281cb3855d911137223c6b6d2dd82a47ae5125a41 \ - --hash=sha256:b4fcdcfa302538f70929eb7b392f536a237cbe2ed9cba88e3bf5027b39f5f77f \ - --hash=sha256:987f15737aba2ab5f3928c617ccf1ce412e2e321c77ab16ca5a293e7bbffd581 \ - --hash=sha256:37f48d46d733d57cc70fd5f30572d11ab8ed92da6e6b28e024e4a3edfb456e37 \ - --hash=sha256:36d829b31ab67d6fcb30e185ec996e1f72b892255a745d3a82138c97d21ed1cd \ - --hash=sha256:8368f83e93c7156ccd40e49a783a6a6850ca25b556c0fa0240ed0f659d2fe496 \ - --hash=sha256:963c80b583b0661918718b095e02303d8078950b26cc00b5e5ea9ababe0de1fc \ - --hash=sha256:e683e409e5c45d5c9082dc1daf13f6374300806240719f95dc783d1fc942af10 \ - --hash=sha256:84aa6223d71012c68d577c83f4e7db50d11d6b1399a9c779046d75e24bed74ea \ - --hash=sha256:a38878a223bdd37c9709d07cd357bb79f4c760b29210e14ad0fb395294583787 \ - --hash=sha256:a2c927c49f2029291fbabd673d51a2180038f8cd5a5b2f290f78c4516be48be2 \ - --hash=sha256:c0c74e5579af4b977c8b932f40a5464764b2f86681327410aa028a22d2f54937 \ - --hash=sha256:07d49388d5bf7e863f7fa2f124b1b1d89d8aa0e2f7812faff0a5658c01c59aa1 \ - --hash=sha256:240296b27397e4e37874abb1df2a608a92df85cf3e2a04d0d4d61055c8305ba6 \ - --hash=sha256:d746a437cdbca200622385305aedd9aef68e8a645e385cc483bdc5e488f07166 \ - --hash=sha256:14bf1522cdee369e8f5581238edac09150c765ec1cb33615855889cf33dcb92d \ - --hash=sha256:cc7b98bf58167b7f2db91a4327da24fb93368838eb84a44c472283778fc2446b \ - --hash=sha256:7147e2a76c75f0f64c4319886e7639e490fee87c9d25cb1d4faef1d8cf83a440 \ - --hash=sha256:9fc0b3cb5d1720e7141d103cf4819aea239f7d136acf9ee4a69b047b7986175a -typing-extensions==3.7.4.3; python_version >= "3.6" \ - --hash=sha256:dafc7639cde7f1b6e1acc0f457842a83e722ccca8eef5270af2d74792619a89f \ - --hash=sha256:7cb407020f00f7bfc3cb3e7881628838e69d8f3fcab2f64742a5e76b2f841918 \ - --hash=sha256:99d4073b617d30288f569d3f13d2bd7548c3a7e4c8de87db09a9d29bb3a4a60c -urllib3==1.26.4; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version < "4" and python_version >= "3.6" \ - --hash=sha256:2f4da4594db7e1e110a944bb1b551fdf4e6c136ad42e4234131391e21eb5b0df \ - --hash=sha256:e7b021f7241115872f92f43c6508082facffbd1c048e3c6e2bb9c2a157e28937 -virtualenv==20.4.3; python_full_version >= "3.6.1" \ - --hash=sha256:83f95875d382c7abafe06bd2a4cdd1b363e1bb77e02f155ebe8ac082a916b37c \ - --hash=sha256:49ec4eb4c224c6f7dd81bb6d0a28a09ecae5894f4e593c89b0db0885f565a107 -wcwidth==0.2.5; python_full_version >= "3.6.1" and python_version >= "3.7" \ - --hash=sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784 \ - --hash=sha256:c4d647b99872929fdb7bdcaa4fbe7f01413ed3d98077df798530e5b04f116c83 -webencodings==0.5.1; python_version >= "3.6" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.6" \ - --hash=sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78 \ - --hash=sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923 -widgetsnbextension==3.5.1; python_version >= "3.6" \ - --hash=sha256:bd314f8ceb488571a5ffea6cc5b9fc6cba0adaf88a9d2386b93a489751938bcd \ - --hash=sha256:079f87d87270bce047512400efd70238820751a11d2d8cb137a5a5bdbaf255c7 diff --git a/tests/test_galsim_hub.py b/tests/test_galsim_hub.py new file mode 100644 index 000000000..15296a852 --- /dev/null +++ b/tests/test_galsim_hub.py @@ -0,0 +1,28 @@ +import btk.draw_blends +import btk.survey + +COSMOS_CATALOG_PATHS = [ + "data/cosmos/real_galaxy_catalog_23.5_example.fits", + "data/cosmos/real_galaxy_catalog_23.5_example_fits.fits", +] + + +def test_draw_galsim_hub(): + stamp_size = 24.0 + batch_size = 2 + catalog = btk.catalog.CosmosCatalog.from_file(COSMOS_CATALOG_PATHS) + sampling_function = btk.sampling_functions.DefaultSamplingGalsimHub(stamp_size=stamp_size) + + draw_generator = btk.draw_blends.GalsimHubGenerator( + catalog, + sampling_function, + [btk.survey.HST], + batch_size=batch_size, + stamp_size=stamp_size, + cpus=1, + add_noise=True, + verbose=True, + meas_bands=["f814w"], + ) + + _ = next(draw_generator)