From f45e6987bf03f433398c8b67091c76aff66265a5 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Mon, 30 Jan 2023 03:02:53 +0100 Subject: [PATCH 01/11] Add multitype REST interface WIP. --- .gitignore | 1 + Dockerfile | 4 +- _version.py | 2 +- ephemerality/__init__.py | 3 + ephemerality/data_processing.py | 20 + .../ephemerality_computation.py | 0 rest/__init__.py | 10 + rest/api.py | 15 +- rest/api11.py | 2 +- .../ephemerality-cmd.py | 2 +- setup.py | 2 +- src/__init__.py | 3 - test/ephemerality_test.py | 6 +- tmp-notebook.ipynb | 793 ++++++++++++++++++ 14 files changed, 847 insertions(+), 16 deletions(-) create mode 100644 ephemerality/__init__.py create mode 100644 ephemerality/data_processing.py rename {src => ephemerality}/ephemerality_computation.py (100%) rename ephemerality.py => scripts/ephemerality-cmd.py (98%) delete mode 100644 src/__init__.py create mode 100644 tmp-notebook.ipynb diff --git a/.gitignore b/.gitignore index 61c7ae1..8a121a7 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ *.idea/ /build/ /venv/ +tmp_* diff --git a/Dockerfile b/Dockerfile index 2ca3cfa..6090ab6 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,9 +1,9 @@ FROM python:3.9.15-slim -ADD src /src +ADD ephemerality /src ADD test /test ADD rest /rest -ADD ephemerality.py / +ADD scripts/ephemerality-cmd.py / ADD requirements.txt / ADD _version.py / ADD setup.py / diff --git a/_version.py b/_version.py index d538f87..ff1068c 100644 --- a/_version.py +++ b/_version.py @@ -1 +1 @@ -__version__ = "1.0.0" \ No newline at end of file +__version__ = "1.1.0" \ No newline at end of file diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py new file mode 100644 index 0000000..70a39d5 --- /dev/null +++ b/ephemerality/__init__.py @@ -0,0 +1,3 @@ +from ephemerality.ephemerality_computation import compute_ephemerality, EphemeralitySet + +__all__ = ['compute_ephemerality', 'EphemeralitySet'] diff --git a/ephemerality/data_processing.py b/ephemerality/data_processing.py new file mode 100644 index 0000000..752548f --- /dev/null +++ b/ephemerality/data_processing.py @@ -0,0 +1,20 @@ +import numpy as np +from datetime import datetime +from typing import Sequence +from rest import InputData + + +def process_input_raw(input_body: InputData) -> tuple(np.ndarray, float): + if input_body.input_type == 'frequencies' or input_body.input_type == 'f': + return input_body.input_sequence, input_body.threshold + elif input_body.input_type == 'timestamps' or input_body.input_type == 't': + return timestamps_to_frequencies(input_body.input_sequence, input_body.range, input_body.granularity),\ + input_body.threshold + else: + raise ValueError('input_type is not one of ["frequencies", "f", "timestamps", "t"]!') + + +def timestamps_to_frequencies(timestamps: Sequence[float | int | str], + range: None | tuple[float | int | str, float | int | str] = None, + granularity: str = 'day') -> np.ndarray[float]: + pass \ No newline at end of file diff --git a/src/ephemerality_computation.py b/ephemerality/ephemerality_computation.py similarity index 100% rename from src/ephemerality_computation.py rename to ephemerality/ephemerality_computation.py diff --git a/rest/__init__.py b/rest/__init__.py index e69de29..23532c2 100644 --- a/rest/__init__.py +++ b/rest/__init__.py @@ -0,0 +1,10 @@ +from api import InputData +from api import get_all_ephemeralities, get_left_core_ephemeralities, get_right_core_ephemeralities +from api import get_middle_core_ephemeralities, get_sorted_core_ephemeralities + + +__all__ = [ + InputData, + get_all_ephemeralities, get_left_core_ephemeralities, get_right_core_ephemeralities, + get_middle_core_ephemeralities, get_sorted_core_ephemeralities +] diff --git a/rest/api.py b/rest/api.py index d537a85..46d92b1 100644 --- a/rest/api.py +++ b/rest/api.py @@ -1,21 +1,28 @@ from fastapi import FastAPI, status from pydantic import BaseModel +from typing import Any, Sequence import rest.api11 as api11 -from src import EphemeralitySet +from ephemerality import EphemeralitySet app = FastAPI() class InputData(BaseModel): - input_vector: list[float] - threshold: float + """ + POST request body format + """ + input_sequence: list[str] + input_type: str = 'frequencies' # 'frequencies' | 'f' | 'timestamps' | 't' + threshold: float = 0.8 + range: None | tuple[str, str] = None # used only if input_type == 'timestamps', defaults to (min(timestamps), max(timestamps) + 1) + granularity: None | str = 'day' # used only if input_type == 'timestamps'; ['week', 'day', 'hour'] @app.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) async def get_all_ephemeralities(api_version: str, input_data: InputData) -> EphemeralitySet: if api_version == '1.1': - return api11.get_all_ephemeralities(input_vector=input_data.input_vector, threshold=input_data.threshold) + return api11.get_all_ephemeralities(input_vector=input_data.input_sequence, threshold=input_data.threshold) else: raise ValueError(f'Unrecognized API version: {api_version}!') diff --git a/rest/api11.py b/rest/api11.py index b386156..e186497 100644 --- a/rest/api11.py +++ b/rest/api11.py @@ -1,5 +1,5 @@ from typing import Sequence -from src import compute_ephemerality, EphemeralitySet +from ephemerality import compute_ephemerality, EphemeralitySet def get_all_ephemeralities(input_vector: Sequence[float], threshold: float) -> EphemeralitySet: diff --git a/ephemerality.py b/scripts/ephemerality-cmd.py similarity index 98% rename from ephemerality.py rename to scripts/ephemerality-cmd.py index a1d050a..5768e89 100644 --- a/ephemerality.py +++ b/scripts/ephemerality-cmd.py @@ -3,7 +3,7 @@ import json import argparse import numpy as np -from src import compute_ephemerality +from ephemerality import compute_ephemerality HELP_INFO = "" diff --git a/setup.py b/setup.py index 7a31bb1..3dab15b 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ def read(file_name): setup( name='ephemerality', version=version, - packages=['src', 'test'], + packages=['ephemerality', 'test'], url='https://github.com/HPAI-BSC/ephemerality', license='MIT', author='HPAI BSC', diff --git a/src/__init__.py b/src/__init__.py deleted file mode 100644 index 5fae7b4..0000000 --- a/src/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from src.ephemerality_computation import compute_ephemerality, EphemeralitySet - -__all__ = ['compute_ephemerality', 'EphemeralitySet'] diff --git a/test/ephemerality_test.py b/test/ephemerality_test.py index 9bfd3b8..2b501fd 100644 --- a/test/ephemerality_test.py +++ b/test/ephemerality_test.py @@ -6,7 +6,7 @@ from dataclasses import dataclass import re -from src import compute_ephemerality +from ephemerality import compute_ephemerality @dataclass @@ -490,11 +490,11 @@ def round_ephemeralities(ephemeralities: dict, precision: int=8): def test_compute_ephemeralities(self): for i, test_case in enumerate(self._test_cases): - print(f'\nRunning test case {i}: {test_case.input_vector}, threshold {test_case.threshold}...') + print(f'\nRunning test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') with warnings.catch_warnings(record=True) as warns: warnings.simplefilter('always', category=RuntimeWarning) - actual_output = compute_ephemerality(frequency_vector=test_case.input_vector, + actual_output = compute_ephemerality(frequency_vector=test_case.input_sequence, threshold=test_case.threshold) self.assertEqual(self.round_ephemeralities(test_case.expected_output), diff --git a/tmp-notebook.ipynb b/tmp-notebook.ipynb new file mode 100644 index 0000000..44ee2df --- /dev/null +++ b/tmp-notebook.ipynb @@ -0,0 +1,793 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import matplotlib\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib as mpl\n", + "import numpy as np\n", + "\n", + "plt.style.use('seaborn-v0_8')\n", + "plt.style.use('seaborn-v0_8-poster')\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "outputs": [ + { + "data": { + "text/plain": "['Solarize_Light2',\n '_classic_test_patch',\n '_mpl-gallery',\n '_mpl-gallery-nogrid',\n 'bmh',\n 'classic',\n 'dark_background',\n 'fast',\n 'fivethirtyeight',\n 'ggplot',\n 'grayscale',\n 'seaborn-v0_8',\n 'seaborn-v0_8-bright',\n 'seaborn-v0_8-colorblind',\n 'seaborn-v0_8-dark',\n 'seaborn-v0_8-dark-palette',\n 'seaborn-v0_8-darkgrid',\n 'seaborn-v0_8-deep',\n 'seaborn-v0_8-muted',\n 'seaborn-v0_8-notebook',\n 'seaborn-v0_8-paper',\n 'seaborn-v0_8-pastel',\n 'seaborn-v0_8-poster',\n 'seaborn-v0_8-talk',\n 'seaborn-v0_8-ticks',\n 'seaborn-v0_8-white',\n 'seaborn-v0_8-whitegrid',\n 'tableau-colorblind10']" + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.style.available" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 85, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[12.8, 8.8]\n", + "17.6\n", + "19.2\n", + "None\n", + "16.0\n", + "16.0\n", + "16.0\n" + ] + } + ], + "source": [ + "print(plt.rcParams.get('figure.figsize'))\n", + "print(plt.rcParams.get('axes.labelsize'))\n", + "print(plt.rcParams.get('axes.titlesize'))\n", + "print(plt.rcParams.get('legend.fontsize'))\n", + "print(plt.rcParams.get('xtick.labelsize'))\n", + "print(plt.rcParams.get('ytick.labelsize'))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 105, + "outputs": [], + "source": [ + "plt.rcParams.update({'axes.labelsize': 22,'axes.titlesize':32, 'legend.fontsize': 20, 'xtick.labelsize': 20, 'ytick.labelsize': 20})" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 54, + "outputs": [], + "source": [ + "FIG_HEIGHT = 6" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 106, + "outputs": [], + "source": [ + "def compute_left_core_length(frequency_vector: np.array, threshold: float) -> int:\n", + " current_sum = 0\n", + " for i, freq in enumerate(frequency_vector):\n", + " current_sum = current_sum + freq\n", + " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", + " return i + 1\n", + "\n", + "\n", + "def compute_right_core_length(frequency_vector: np.array, threshold: float) -> int:\n", + " current_sum = 0\n", + " for i, freq in enumerate(frequency_vector[::-1]):\n", + " current_sum = current_sum + freq\n", + " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", + " return i + 1\n", + "\n", + "\n", + "def compute_middle_core_range(frequency_vector: np.array, threshold: float) -> tuple[int, int]:\n", + " lower_threshold = (1. - threshold) / 2\n", + "\n", + " current_presum = 0\n", + " start_index = -1\n", + " for i, freq in enumerate(frequency_vector):\n", + " current_presum += freq\n", + " if current_presum > lower_threshold and not np.isclose(current_presum, lower_threshold):\n", + " start_index = i\n", + " break\n", + "\n", + " current_sum = 0\n", + " for j, freq in enumerate(frequency_vector[start_index:]):\n", + " current_sum += freq\n", + " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", + " return start_index, j + 1\n", + "\n", + "def compute_middle_core_length(frequency_vector: np.array, threshold: float) -> int:\n", + " return compute_middle_core_range(frequency_vector, threshold)[1]\n", + "\n", + "\n", + "def compute_sorted_core_length(frequency_vector: np.array, threshold: float) -> int:\n", + " freq_descending_order = np.sort(frequency_vector)[::-1]\n", + "\n", + " current_sum = 0\n", + " for i, freq in enumerate(freq_descending_order):\n", + " current_sum += freq\n", + " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", + " return i + 1\n", + "\n", + "\n", + "def _compute_ephemerality_from_core(core_length: int, range_length: int, threshold: float) -> float:\n", + " return max(0., 1 - (core_length / range_length) / threshold)\n", + "\n", + "def plot_threshold(vector, step: int=0.05, title: str = \"Vector\"):\n", + " fig, axs = plt.subplots(2, 2)\n", + "\n", + " ephemerality_vector = list()\n", + " X = np.arange(step, 1, step)\n", + " for threshold in X:\n", + " ephemerality_vector.append(_compute_ephemerality_from_core(compute_left_core_length(vector, threshold), len(vector), threshold))\n", + " axs[0, 0].plot(X, ephemerality_vector, '.-')\n", + " axs[0, 0].set_xlabel(\"Threshold\")\n", + " axs[0, 0].set_ylabel(\"Ephemerality\")\n", + " axs[0, 0].set_title(rf\"$\\epsilon_l\\left(\\alpha\\right)$ for {title.lower()}\")\n", + " axs[0, 0].set_ylim([0., 1.])\n", + "\n", + " ephemerality_vector = list()\n", + " X = np.arange(step, 1, step)\n", + " for threshold in X:\n", + " ephemerality_vector.append(_compute_ephemerality_from_core(compute_right_core_length(vector, threshold), len(vector), threshold))\n", + " axs[0, 1].plot(X, ephemerality_vector, '.-')\n", + " axs[0, 1].set_xlabel(\"Threshold\")\n", + " axs[0, 1].set_ylabel(\"Ephemerality\")\n", + " axs[0, 1].set_title(rf\"$\\epsilon_r\\left(\\alpha\\right) for {title.lower()}$\")\n", + " axs[0, 1].set_ylim([0., 1.])\n", + "\n", + " ephemerality_vector = list()\n", + " X = np.arange(step, 1, step)\n", + " for threshold in X:\n", + " ephemerality_vector.append(_compute_ephemerality_from_core(compute_middle_core_length(vector, threshold), len(vector), threshold))\n", + " axs[1, 0].plot(X, ephemerality_vector, '.-')\n", + " axs[1, 0].set_xlabel(\"Threshold\")\n", + " axs[1, 0].set_ylabel(\"Ephemerality\")\n", + " axs[1, 0].set_title(rf\"$\\epsilon_m\\left(\\alpha\\right) for {title.lower()}$\")\n", + " axs[1, 0].set_ylim([0., 1.])\n", + "\n", + " ephemerality_vector = list()\n", + " X = np.arange(step, 1, step)\n", + " for threshold in X:\n", + " ephemerality_vector.append(_compute_ephemerality_from_core(compute_sorted_core_length(vector, threshold), len(vector), threshold))\n", + " axs[1, 1].plot(X, ephemerality_vector, '.-')\n", + " axs[1, 1].set_xlabel(\"Threshold\")\n", + " axs[1, 1].set_ylabel(\"Ephemerality\")\n", + " axs[1, 1].set_title(rf\"$\\epsilon_s\\left(\\alpha\\right) for {title.lower()}$\")\n", + " axs[1, 1].set_ylim([0., 1.])\n", + "\n", + " fig.tight_layout()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 127, + "outputs": [], + "source": [ + "def fill(ax, y, x_start, x_end, color):\n", + " x = np.arange(0, len(y))\n", + " ax.fill_between(x, y, -1., where=(x_start <= x) & (x < x_end), color=color)\n", + " ax.fill_between(x, 1., y, where=(x_start <= x) & (x < x_end), hatch='//', facecolor='lightsalmon')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 131, + "outputs": [], + "source": [ + "def plot_all(vector, ylim, title, threshold, save_path=\"\"):\n", + " title_size = plt.rcParams.get('axes.titlesize')\n", + " plt.rcParams.update({'axes.titlesize': 44})\n", + " plt.figure(figsize=[12.8, FIG_HEIGHT])\n", + " plt.plot(vector, '.-', color='#912916')\n", + " plt.ylim(ylim)\n", + " plt.xlabel(\"Time\")\n", + " plt.ylabel(\"Normalized activity\")\n", + " plt.title(title, fontweight='bold')\n", + " plt.tight_layout()\n", + " if save_path:\n", + " plt.savefig(f\"{save_path}{title}.png\", bbox_inches='tight')\n", + "\n", + " plt.rcParams.update({'axes.titlesize': title_size})\n", + "\n", + " left_core = compute_left_core_length(vector, threshold)\n", + " right_core = compute_right_core_length(vector, threshold)\n", + " middle_core = compute_middle_core_range(vector, threshold)\n", + " sorted_core = compute_sorted_core_length(vector, threshold)\n", + "\n", + " ephemeralities = {\n", + " \"left_core\": _compute_ephemerality_from_core(left_core, len(vector), threshold),\n", + " \"right_core\": _compute_ephemerality_from_core(right_core, len(vector), threshold),\n", + " \"middle_core\": _compute_ephemerality_from_core(middle_core[1], len(vector), threshold),\n", + " \"sorted_core\": _compute_ephemerality_from_core(sorted_core, len(vector), threshold),\n", + " }\n", + "\n", + " fig, axs = plt.subplots(2, 2)\n", + " fig.set_figheight(FIG_HEIGHT + 1)\n", + " axs[0, 0].plot(vector, '.-', color='#912916')\n", + " fill(axs[0, 0], vector, 0, left_core, color='coral')\n", + " axs[0, 0].set_ylim(ylim)\n", + " axs[0, 0].set_xlabel(\"Time\")\n", + " axs[0, 0].set_ylabel(\"Activity\")\n", + " cur_title = rf\"${int(threshold * 100)}\\%$ left core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['left_core'], 2)}$\"\n", + " axs[0, 0].set_title(cur_title)\n", + "\n", + " axs[0, 1].plot(vector, '.-', color='#912916')\n", + " fill(axs[0, 1], vector, len(vector) - right_core, len(vector), color='coral')\n", + " axs[0, 1].set_ylim(ylim)\n", + " axs[0, 1].set_xlabel(\"Time\")\n", + " cur_title = rf\"${int(threshold * 100)}\\%$ right core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['right_core'], 2)}$\"\n", + " axs[0, 1].set_title(cur_title)\n", + "\n", + " axs[1, 0].plot(vector, '.-', color='#912916')\n", + " fill(axs[1, 0], vector, middle_core[0], middle_core[0] + middle_core[1], color='coral')\n", + " axs[1, 0].set_ylim(ylim)\n", + " axs[1, 0].set_xlabel(\"Time\")\n", + " axs[1, 0].set_ylabel(\"Activity\")\n", + " cur_title = rf\"${int(threshold * 100)}\\%$ middle core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['middle_core'], 2)}$\"\n", + " axs[1, 0].set_title(cur_title)\n", + "\n", + " sorted_vector = np.sort(vector)[::-1]\n", + " axs[1, 1].plot(sorted_vector, '.-', color='#912916')\n", + " fill(axs[1, 1], sorted_vector, 0, sorted_core, color='coral')\n", + " axs[1, 1].set_ylim(ylim)\n", + " axs[1, 1].set_xlabel(\"Sorted activity vector\")\n", + " cur_title = rf\"${int(threshold * 100)}\\%$ sorted core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['sorted_core'], 2)}$\"\n", + " axs[1, 1].set_title(cur_title)\n", + "\n", + " fig.tight_layout()\n", + "\n", + " if save_path:\n", + " plt.savefig(f\"{save_path}{title} with cores.png\")\n", + "\n", + " return ephemeralities" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [ + "one_peak_vector = np.array([1,2,7,5,2,4,5,3,10,5,6,45,98,287,261,150,29,11,2,8,5,3,3,5,6,2], dtype=float)\n", + "one_peak_vector /= np.sum(one_peak_vector)\n", + "# print(len(one_peak_vector))\n", + "# plt.plot(one_peak_vector, '.-', color='#912916')\n", + "# plt.ylim([0,0.31])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 132, + "outputs": [ + { + "data": { + "text/plain": "{'left_core': 0.3162393162393162,\n 'right_core': 0.4017094017094017,\n 'middle_core': 0.7008547008547008,\n 'sorted_core': 0.7435897435897436}" + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_all(one_peak_vector, [-0.02,0.31], \"Single peak\", 0.9, save_path=\"D:\\\\Dropbox\\\\BSC\\\\AI4Media\\\\Plenary 2023\\\\\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 41, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_threshold(one_peak_vector, title=\"One peak\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 24, + "outputs": [], + "source": [ + "two_peaks_vector = np.array([8,1,5,35,160,162,45,12,9,4,6,6,3,7,5,2,3,2,57,120,222,78,23,1,9,4], dtype=float)\n", + "two_peaks_vector /= np.sum(two_peaks_vector)\n", + "# print(len(two_peaks_vector))\n", + "# plt.plot(two_peaks_vector, '.-', color='#912916')\n", + "# plt.ylim([0,0.31])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 133, + "outputs": [ + { + "data": { + "text/plain": "{'left_core': 0.05982905982905984,\n 'right_core': 0.05982905982905984,\n 'middle_core': 0.23076923076923084,\n 'sorted_core': 0.6153846153846154}" + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_all(two_peaks_vector, [0,0.31], \"Two peaks\", 0.9, save_path=\"D:\\\\Dropbox\\\\BSC\\\\AI4Media\\\\Plenary 2023\\\\\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 42, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_threshold(two_peaks_vector, title=\"Two peaks\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 27, + "outputs": [], + "source": [ + "np.random.seed(1101)\n", + "uni = np.random.uniform(2, 8, (26,))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 28, + "outputs": [], + "source": [ + "uniform = uni.copy()\n", + "uniform[20] = 11.\n", + "uniform /= np.sum(uniform)\n", + "# print(len(uniform))\n", + "# plt.plot(uniform, '.-', color='#912916')\n", + "# plt.ylim([0,0.31])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 134, + "outputs": [ + { + "data": { + "text/plain": "{'left_core': 0.0,\n 'right_core': 0.0,\n 'middle_core': 0.0,\n 'sorted_core': 0.1826923076923077}" + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_all(uniform, [0,0.31], \"Uniform\", 0.8, save_path=\"D:\\\\Dropbox\\\\BSC\\\\AI4Media\\\\Plenary 2023\\\\\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 43, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_threshold(uniform, title=\"Uniform\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 889d0bd914ac9473c3a6bccdb3bd3a7d4fba796f Mon Sep 17 00:00:00 2001 From: Dmitry Date: Wed, 29 Mar 2023 13:02:22 +0200 Subject: [PATCH 02/11] Remove `less than zero` warnings and add core lengths to outputs --- ephemerality/ephemerality_computation.py | 124 +++++++----------- ...emerality_test.py => test_ephemerality.py} | 0 2 files changed, 51 insertions(+), 73 deletions(-) rename test/{ephemerality_test.py => test_ephemerality.py} (100%) diff --git a/ephemerality/ephemerality_computation.py b/ephemerality/ephemerality_computation.py index 2486067..4f47898 100644 --- a/ephemerality/ephemerality_computation.py +++ b/ephemerality/ephemerality_computation.py @@ -1,15 +1,34 @@ import numpy as np from typing import Sequence from pydantic import BaseModel -import warnings class EphemeralitySet(BaseModel): - """Class to contain ephemerality values by subtypes""" - left_core: float = None - middle_core: float = None - right_core: float = None - sorted_core: float = None + """Class to contain ephemerality core size values by subtypes""" + len_left_core: int | None = None + len_middle_core: int | None = None + len_right_core: int | None = None + len_sorted_core: int | None = None + + eph_left_core: float | None = None + eph_middle_core: float | None = None + eph_right_core: float | None = None + eph_sorted_core: float | None = None + + +def _check_threshold(threshold: float) -> bool: + if threshold <= 0.: + raise ValueError('Threshold value must be greater than 0!') + + if threshold > 1.: + raise ValueError('Threshold value must be less or equal to 1!') + + return True + + +def _ephemerality_raise_error(threshold: float): + if _check_threshold(threshold): + raise ValueError('Input frequency vector has not been internally normalized (problematic data format?)!') def _normalize_frequency_vector(frequency_vector: Sequence[float]) -> np.array: @@ -21,13 +40,6 @@ def _normalize_frequency_vector(frequency_vector: Sequence[float]) -> np.array: return frequency_vector -def _ephemerality_raise_error(threshold: float): - if 0. < threshold <= 1: - raise ValueError('Input frequency vector has not been internally normalized!') - else: - raise ValueError('Threshold value is not within (0, 1] range!') - - def compute_left_core_length(frequency_vector: np.array, threshold: float) -> int: current_sum = 0 for i, freq in enumerate(frequency_vector): @@ -81,15 +93,7 @@ def compute_sorted_core_length(frequency_vector: np.array, threshold: float) -> def _compute_ephemerality_from_core(core_length: int, range_length: int, threshold: float): - return 1 - (core_length / range_length) / threshold - - -def _check_threshold(threshold: float): - if threshold <= 0.: - raise ValueError('Threshold value must be greater than 0!') - - if threshold > 1.: - raise ValueError('Threshold value must be less or equal to 1!') + return max(0., 1 - (core_length / range_length) / threshold) def compute_ephemerality( @@ -99,76 +103,50 @@ def compute_ephemerality( _check_threshold(threshold) - if np.isclose(np.sum(frequency_vector), 0.): - return EphemeralitySet( - left_core=1., - middle_core=1., - right_core=1., - sorted_core=1. - ) + if np.sum(frequency_vector) == 0.: + raise ZeroDivisionError("Frequency vector's sum is 0!") frequency_vector = _normalize_frequency_vector(frequency_vector) range_length = len(frequency_vector) if types == 'all' or types == 'left': - left_core_length = compute_left_core_length(frequency_vector, threshold) - ephemerality_left_core = _compute_ephemerality_from_core(left_core_length, range_length, threshold) - if ephemerality_left_core < 0. and not np.isclose(ephemerality_left_core, 0.): - warnings.warn(f'Original ephemerality value is less than 0 ({ephemerality_left_core}) and is going to be rounded up! ' - f'This is indicative of the edge case in which ephemerality span is greater than ' - f'[threshold * input_vector_length], i.e. most of the frequency mass lies in a few vector ' - f'elements at the end of the frequency vector. Original ephemerality in this case should be ' - f'considered to be equal to 0. However, please double check the input vector!', - RuntimeWarning) - ephemerality_left_core = 0. + length_left_core = compute_left_core_length(frequency_vector, threshold) + ephemerality_left_core = _compute_ephemerality_from_core(length_left_core, range_length, threshold) else: + length_left_core = None ephemerality_left_core = None if types == 'all' or types == 'middle': - middle_core_length = compute_middle_core_length(frequency_vector, threshold) - ephemerality_middle_core = _compute_ephemerality_from_core(middle_core_length, range_length, threshold) - if ephemerality_middle_core < 0. and not np.isclose(ephemerality_middle_core, 0.): - warnings.warn(f'Filtered ephemerality value is less than 0 ({ephemerality_middle_core}) and is going to be rounded up! ' - f'This is indicative of the edge case in which ephemerality span is greater than ' - f'[threshold * input_vector_length], i.e. most of the frequency mass lies in a few elements ' - f'at the beginning and the end of the frequency vector. Filtered ephemerality in this case should ' - f'be considered to be equal to 0. However, please double check the input vector!', - RuntimeWarning) - ephemerality_middle_core = 0. + length_middle_core = compute_middle_core_length(frequency_vector, threshold) + ephemerality_middle_core = _compute_ephemerality_from_core(length_middle_core, range_length, threshold) else: + length_middle_core = None ephemerality_middle_core = None if types == 'all' or types == 'right': - right_core_length = compute_right_core_length(frequency_vector, threshold) - ephemerality_right_core = _compute_ephemerality_from_core(right_core_length, range_length, threshold) - if ephemerality_right_core < 0. and not np.isclose(ephemerality_right_core, 0.): - warnings.warn(f'Original ephemerality value is less than 0 ({ephemerality_right_core}) and is going to be rounded up! ' - f'This is indicative of the edge case in which ephemerality span is greater than ' - f'[threshold * input_vector_length], i.e. most of the frequency mass lies in a few vector ' - f'elements at the end of the frequency vector. Original ephemerality in this case should be ' - f'considered to be equal to 0. However, please double check the input vector!', - RuntimeWarning) - ephemerality_right_core = 0. + length_right_core = compute_right_core_length(frequency_vector, threshold) + ephemerality_right_core = _compute_ephemerality_from_core(length_right_core, range_length, threshold) else: + length_right_core =None ephemerality_right_core = None if types == 'all' or types == 'sorted': - sorted_core_length = compute_sorted_core_length(frequency_vector, threshold) - ephemerality_sorted_core = _compute_ephemerality_from_core(sorted_core_length, range_length, threshold) - if ephemerality_sorted_core < 0. and not np.isclose(ephemerality_sorted_core, 0.): - warnings.warn(f'Sorted ephemerality value is less than 0 ({ephemerality_sorted_core}) and is going to be rounded up! ' - f'This is indicative of the rare edge case of very short and mostly uniform frequency vector (so ' - f'that ephemerality span is greater than [threshold * input_vector_length]). ' - f'Sorted ephemerality in this case should be considered to be equal to 0. ' - f'However, please double check the input vector!', - RuntimeWarning) - ephemerality_sorted_core = 0. + length_sorted_core = compute_sorted_core_length(frequency_vector, threshold) + ephemerality_sorted_core = _compute_ephemerality_from_core(length_sorted_core, range_length, threshold) else: + length_sorted_core = None ephemerality_sorted_core = None - ephemeralities = EphemeralitySet(left_core=ephemerality_left_core, - middle_core=ephemerality_middle_core, - right_core=ephemerality_right_core, - sorted_core=ephemerality_sorted_core) + ephemeralities = EphemeralitySet( + len_left_core=length_left_core, + len_middle_core=length_middle_core, + len_right_core=length_right_core, + len_sorted_core=length_sorted_core, + + eph_left_core=ephemerality_left_core, + eph_middle_core=ephemerality_middle_core, + eph_right_core=ephemerality_right_core, + eph_sorted_core=ephemerality_sorted_core + ) return ephemeralities diff --git a/test/ephemerality_test.py b/test/test_ephemerality.py similarity index 100% rename from test/ephemerality_test.py rename to test/test_ephemerality.py From b3369a5c0d93968d3fb56f767c957af5a7230184 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Thu, 13 Apr 2023 21:18:33 +0200 Subject: [PATCH 03/11] Clean ephemerality code, add testing scripts (alfa), update API. --- .gitignore | 12 +- Dockerfile | 2 +- ephemerality.egg-info/PKG-INFO | 151 +++++ ephemerality.egg-info/SOURCES.txt | 10 + ephemerality.egg-info/dependency_links.txt | 1 + ephemerality.egg-info/top_level.txt | 2 + ephemerality/__init__.py | 6 +- ephemerality/data_processing.py | 153 ++++- ephemerality/ephemerality_computation.py | 27 +- ephemerality/utils.py | 32 + requirements.txt | 13 +- rest/__init__.py | 17 +- rest/api.py | 112 ++-- rest/api11.py | 18 - rest/api_versions/__init__.py | 11 + rest/api_versions/api11.py | 19 + rest/api_versions/api_template.py | 19 + scripts/ephemerality-api.py | 12 + scripts/ephemerality-cmd.py | 129 ++-- scripts/test_performance.py | 165 +++++ setup.py | 2 +- test/__init__.py | 0 test/test_ephemerality.py | 510 ---------------- testing/__init__.py | 4 + testing/data_generator.py | 37 ++ testing/test_ephemerality.py | 670 +++++++++++++++++++++ testing/test_utils.py | 10 + tmp-notebook.ipynb | 2 +- 28 files changed, 1479 insertions(+), 667 deletions(-) create mode 100644 ephemerality.egg-info/PKG-INFO create mode 100644 ephemerality.egg-info/SOURCES.txt create mode 100644 ephemerality.egg-info/dependency_links.txt create mode 100644 ephemerality.egg-info/top_level.txt create mode 100644 ephemerality/utils.py delete mode 100644 rest/api11.py create mode 100644 rest/api_versions/__init__.py create mode 100644 rest/api_versions/api11.py create mode 100644 rest/api_versions/api_template.py create mode 100644 scripts/ephemerality-api.py create mode 100644 scripts/test_performance.py delete mode 100644 test/__init__.py delete mode 100644 test/test_ephemerality.py create mode 100644 testing/__init__.py create mode 100644 testing/data_generator.py create mode 100644 testing/test_ephemerality.py create mode 100644 testing/test_utils.py diff --git a/.gitignore b/.gitignore index 8a121a7..f019044 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,10 @@ /tmp/ -/test/.pytest_cache/ -*.json -*.pyc -*.idea/ +**/.pytest_cache/ +**/*.json +**/*.pyc +**/*.idea/ /build/ /venv/ -tmp_* +**/tmp_* +**/tmp-* +/testing/test_data/ diff --git a/Dockerfile b/Dockerfile index 6090ab6..d002053 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,7 +1,7 @@ FROM python:3.9.15-slim ADD ephemerality /src -ADD test /test +ADD testing /test ADD rest /rest ADD scripts/ephemerality-cmd.py / ADD requirements.txt / diff --git a/ephemerality.egg-info/PKG-INFO b/ephemerality.egg-info/PKG-INFO new file mode 100644 index 0000000..47c2ad3 --- /dev/null +++ b/ephemerality.egg-info/PKG-INFO @@ -0,0 +1,151 @@ +Metadata-Version: 2.1 +Name: ephemerality +Version: 1.0.0 +Summary: Module for computing ephemerality metrics of temporal arrays. +Home-page: https://github.com/HPAI-BSC/ephemerality +Author: HPAI BSC +Author-email: dmitry.gnatyshak@bsc.es +License: MIT +Platform: UNKNOWN + +# Ephemerality metric +In [[1]](#1) we formalized the ephemerality metrics used to estimate the healthiness of online discussions. It shows how +'ephemeral' topics are, that is whether the discussions are more or less uniformly active or only revolve around one or +several peaks of activity. + +### Requirements +The code was tested to work with Python 3.8.6 and Numpy 1.21.5, but is expected to also run on their older versions. + +## How to run the experiments +The code can be run directly via the calculate_ephemerality.py script or via a Docker container built with the provided +Dockerfile. + +### Input +The script/container expect the following input arguments: + +* **Frequency vector file**. `[-i PATH, --input PATH]` _Optional_. Path to a file containing one or several arrays of +numbers in csv format (one array per line), representing temporal frequency vectors. They do not need to be normalized: +if they are not --- they will be normalized automatically. +* **Frequency vector**. _Optional_. If input file is not provided, a frequency vector is expected as a positional +argument (either comma- or space-separated). +* **Output file**. `[-o PATH, --output PATH]` _Optional_. If it is provided, the results will be written into this file +in JSON format. +* **Threshold**. `[-t FLOAT, -threshold FLOAT]` _Optional_. Threshold value for ephemerality computations. Defaults +to 0.8. +* **Print**. `[-p, --print]`. _Optional_. If output file is provided, forces the results to still be printed to stdout. + +### Output +If no output file specified or `-p` option is used, results are printed to STDOUT in **[εorig +εorig_span εfiltered εfiltered_span εsorted εsorted_span]** +format, one line per each line of input file (or a single line for command line input). + +If the output file was specified among the input arguments, the results will be written into that file in JSON format as +a list of dictionaries, one per input line: + +``` +[ + { + "ephemerality_original": FLOAT, + "ephemerality_original_span": INT, + "ephemerality_filtered": FLOAT, + "ephemerality_filtered_span": INT, + "ephemerality_sorted": FLOAT, + "ephemerality_sorted_span": INT + }, + ... +] +``` + +### Example + +Input file `test_input.csv`: +``` +0.0,0.0,0.0,0.2,0.55,0.0,0.15,0.1,0.0,0.0 +``` + +#### Python execution: + +Input 1: + +``` +python ephemerality.py -i tmp/test_input.csv -t 0.8 --output tmp/test_output.json -P +``` + +Output 1: +``` +0.1250000000000001 7 0.5 4 0.625 3 +0.2500000000000001 3 0.5 2 0.5 2 +``` + +`test_output.json` content: +``` +[ + { + "ephemerality_original": 0.1250000000000001, + "ephemerality_original_span": 7, + "ephemerality_filtered": 0.5, + "ephemerality_filtered_span": 4, + "ephemerality_sorted": 0.625, + "ephemerality_sorted_span": 3 + }, + { + "ephemerality_original": 0.2500000000000001, + "ephemerality_original_span": 3, + "ephemerality_filtered": 0.5, + "ephemerality_filtered_span": 2, + "ephemerality_sorted": 0.5, + "ephemerality_sorted_span": 2 + } +] +``` + +Input 2: + +``` +python ephemerality.py 0.0 0.0 0.0 0.2 0.55 0.0 0.15 0.1 0.0 0.0 -t 0.5 +``` + +Output 2: +``` +0.0 5 0.8 1 0.8 1 +``` + +#### Docker execution +``` +docker run -a STDOUT -v [PATH_TO_FOLDER]/tmp/:/tmp/ ephemerality:1.0.0 -i /tmp/test_input.csv -o /tmp/test_output.json -t 0.5 -p +``` + +Output: +``` +0.0 5 0.8 1 0.8 1 +0.19999999999999996 2 0.6 1 0.6 1 +``` + +`test_output.json` content: +``` +[ + { + "ephemerality_original": 0.0, + "ephemerality_original_span": 5, + "ephemerality_filtered": 0.8, + "ephemerality_filtered_span": 1, + "ephemerality_sorted": 0.8, + "ephemerality_sorted_span": 1 + }, + { + "ephemerality_original": 0.19999999999999996, + "ephemerality_original_span": 2, + "ephemerality_filtered": 0.6, + "ephemerality_filtered_span": 1, + "ephemerality_sorted": 0.6, + "ephemerality_sorted_span": 1 + } +] +``` + + +## References +[1] +Gnatyshak, D., Garcia-Gasulla, D., Alvarez-Napagao, S., Arjona, J., & Venturini, T. (2022). Healthy Twitter discussions? Time will tell. arXiv preprint arXiv:2203.11261 + + diff --git a/ephemerality.egg-info/SOURCES.txt b/ephemerality.egg-info/SOURCES.txt new file mode 100644 index 0000000..1d38aee --- /dev/null +++ b/ephemerality.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +ephemerality.egg-info/PKG-INFO +ephemerality.egg-info/SOURCES.txt +ephemerality.egg-info/dependency_links.txt +ephemerality.egg-info/top_level.txt +src/__init__.py +src/ephemerality_computation.py +test/__init__.py +test/test_ephemerality.py \ No newline at end of file diff --git a/ephemerality.egg-info/dependency_links.txt b/ephemerality.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/ephemerality.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/ephemerality.egg-info/top_level.txt b/ephemerality.egg-info/top_level.txt new file mode 100644 index 0000000..281df39 --- /dev/null +++ b/ephemerality.egg-info/top_level.txt @@ -0,0 +1,2 @@ +src +test diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py index 70a39d5..5ad0400 100644 --- a/ephemerality/__init__.py +++ b/ephemerality/__init__.py @@ -1,3 +1,5 @@ -from ephemerality.ephemerality_computation import compute_ephemerality, EphemeralitySet +from ephemerality.ephemerality_computation import compute_ephemerality +from ephemerality.data_processing import process_input, InputData +from ephemerality.utils import ResultSet -__all__ = ['compute_ephemerality', 'EphemeralitySet'] +__all__ = [compute_ephemerality, ResultSet, process_input, InputData] diff --git a/ephemerality/data_processing.py b/ephemerality/data_processing.py index 752548f..f7ce642 100644 --- a/ephemerality/data_processing.py +++ b/ephemerality/data_processing.py @@ -1,20 +1,151 @@ import numpy as np -from datetime import datetime +from datetime import datetime, timezone, timedelta +from pathlib import Path +from pydantic import BaseModel from typing import Sequence -from rest import InputData +import json +import warnings -def process_input_raw(input_body: InputData) -> tuple(np.ndarray, float): - if input_body.input_type == 'frequencies' or input_body.input_type == 'f': - return input_body.input_sequence, input_body.threshold - elif input_body.input_type == 'timestamps' or input_body.input_type == 't': - return timestamps_to_frequencies(input_body.input_sequence, input_body.range, input_body.granularity),\ - input_body.threshold +SECONDS_WEEK = 604800. +SECONDS_DAY = 86400. +SECONDS_HOUR = 3600. + + +class InputData(BaseModel): + """ + POST request body format + """ + input: list[str] + input_type: str = 'f' # 'frequencies' | 'f' | 'timestamps' | 't' | 'datetime' | 'd' + threshold: float = 0.8 + time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format + timezone: float = 0. # used only if input_type == 'datetime' | 'd'. Offset in hours from the UTC time. Should be within [-24, +24] range. + range: None | tuple[str, str] = None # used only if input_type == 'timestamps' | 't', defaults to (min(timestamps), max(timestamps) + 1) + granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't'. {'week', 'day', 'hour', '_d', '_h'} + + +def process_input( + input_folder: str | Path | None = None, + recursive: bool = True, + input_file: str | Path | None = None, + input_remote_data: InputData | None = None, + input_dict: dict | None = None, + input_seq: Sequence[float | int | str] | None = None, + threshold: float=0.8) -> list[tuple[np.ndarray[float], float]]: + output = [] + + if input_folder: + output.extend(process_folder(path=Path(input_folder), recursive=recursive, threshold=threshold)) + + if input_file: + output.extend(process_file(path=Path(input_file), threshold=threshold)) + + if input_remote_data: + output.extend(process_formatted_data(input_remote_data)) + + if input_dict: + output.extend(process_formatted_data(InputData(**input_dict))) + + if input_seq: + if threshold is None: + raise ValueError('Threshold value is not defined!') + output.append((np.ndarray(input_seq, dtype=float), threshold)) + + return output + +def process_folder(path: Path, recursive: bool = True, threshold: float | None = None) -> list[tuple[np.ndarray[float], float]]: + output = [] + for file in path.iterdir(): + if file.is_file(): + output.extend(process_file(path=file, threshold=threshold)) + elif file.is_dir() and recursive: + output.extend(process_folder(path=file, recursive=recursive, threshold=threshold)) + return output + + +def process_file(path: Path, threshold: float | None = None) -> list[tuple[np.ndarray[float], float]]: + if path.suffix == '.json': + return process_json(path) + elif path.suffix == '.csv': + return [(sequence, threshold) for sequence in process_csv(path)] + else: + return [] + + +def process_json(path: Path) -> list[tuple[np.ndarray[float], float]]: + with open(path, 'r') as f: + input_object = json.load(f) + + if isinstance(input_object, dict): + input_object = [input_object] + + output = [] + for input_case in input_object: + input_case = InputData(**input_case) + try: + process_formatted_data(input_case) + except ValueError: + warnings.warn(f'\"input_type\" is not one of ["frequencies", "f", "timestamps", "t"]! Ignoring file \"{str(path.absolute())}\"!') + + return output + + +def process_formatted_data(input_data: InputData) -> tuple[np.ndarray[float], float]: + if input_data.input_type == 'frequencies' or input_data.input_type == 'f': + return np.array(input_data.input), input_data.threshold + elif input_data.input_type == 'timestamps' or input_data.input_type == 't': + return timestamps_to_frequencies(np.array(input_data.input, dtype=float), input_data.range, + input_data.granularity), input_data.threshold + elif input_data.input_type == 'datetime' or input_data.input_type == 'd': + timestamps = [datetime.strptime(time_point, input_data.time_format).replace(tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() + for time_point in input_data.input] + return timestamps_to_frequencies(np.array(timestamps, dtype=float), input_data.range, + input_data.granularity), input_data.threshold else: - raise ValueError('input_type is not one of ["frequencies", "f", "timestamps", "t"]!') + raise ValueError("Wrong \"input_type\" value!") + + +def process_csv(path: Path) -> list[np.ndarray[float]]: + output = [] + with open(path, 'r') as f: + for line in f: + if line: + output.append(np.fromstring(line.strip(), dtype=float, sep=',')) + return output def timestamps_to_frequencies(timestamps: Sequence[float | int | str], - range: None | tuple[float | int | str, float | int | str] = None, + ts_range: None | tuple[float | int | str, float | int | str] = None, granularity: str = 'day') -> np.ndarray[float]: - pass \ No newline at end of file + if not isinstance(timestamps, np.ndarray) or timestamps.dtype != float: + timestamps = np.array(timestamps, dtype=float) + if ts_range is None: + ts_range = (np.min(timestamps), np.max(timestamps)) + if granularity == 'week': + bin_width = SECONDS_WEEK + elif granularity == 'day': + bin_width = SECONDS_DAY + elif granularity == 'hour': + bin_width = SECONDS_HOUR + elif granularity[-1] == 'd' and _is_float(granularity[:-1]): + bin_width = float(granularity[:-1]) * SECONDS_DAY + elif granularity[-1] == 'h' and _is_float(granularity[:-1]): + bin_width = float(granularity[:-1]) * SECONDS_HOUR + else: + raise ValueError(f"Invalid granularity value: {granularity}!") + + bins = np.arange(ts_range[0], ts_range[1], bin_width) + if not np.isclose(bins[-1], ts_range[1]): + bins = np.append(bins, ts_range[1]) + + frequency, _ = np.histogram(np.array(timestamps, dtype=float), bins=bins) + return frequency + + +def _is_float(num: str) -> bool: + try: + tmp = float(num) + except ValueError: + return False + return True diff --git a/ephemerality/ephemerality_computation.py b/ephemerality/ephemerality_computation.py index 4f47898..5973856 100644 --- a/ephemerality/ephemerality_computation.py +++ b/ephemerality/ephemerality_computation.py @@ -1,19 +1,6 @@ import numpy as np from typing import Sequence -from pydantic import BaseModel - - -class EphemeralitySet(BaseModel): - """Class to contain ephemerality core size values by subtypes""" - len_left_core: int | None = None - len_middle_core: int | None = None - len_right_core: int | None = None - len_sorted_core: int | None = None - - eph_left_core: float | None = None - eph_middle_core: float | None = None - eph_right_core: float | None = None - eph_sorted_core: float | None = None +from ephemerality.utils import ResultSet def _check_threshold(threshold: float) -> bool: @@ -99,7 +86,7 @@ def _compute_ephemerality_from_core(core_length: int, range_length: int, thresho def compute_ephemerality( frequency_vector: Sequence[float], threshold: float = 0.8, - types: str = 'all') -> EphemeralitySet: + types: str = 'lmrs') -> ResultSet: _check_threshold(threshold) @@ -109,35 +96,35 @@ def compute_ephemerality( frequency_vector = _normalize_frequency_vector(frequency_vector) range_length = len(frequency_vector) - if types == 'all' or types == 'left': + if 'l' in types: length_left_core = compute_left_core_length(frequency_vector, threshold) ephemerality_left_core = _compute_ephemerality_from_core(length_left_core, range_length, threshold) else: length_left_core = None ephemerality_left_core = None - if types == 'all' or types == 'middle': + if 'm' in types: length_middle_core = compute_middle_core_length(frequency_vector, threshold) ephemerality_middle_core = _compute_ephemerality_from_core(length_middle_core, range_length, threshold) else: length_middle_core = None ephemerality_middle_core = None - if types == 'all' or types == 'right': + if 'r' in types: length_right_core = compute_right_core_length(frequency_vector, threshold) ephemerality_right_core = _compute_ephemerality_from_core(length_right_core, range_length, threshold) else: length_right_core =None ephemerality_right_core = None - if types == 'all' or types == 'sorted': + if 's' in types: length_sorted_core = compute_sorted_core_length(frequency_vector, threshold) ephemerality_sorted_core = _compute_ephemerality_from_core(length_sorted_core, range_length, threshold) else: length_sorted_core = None ephemerality_sorted_core = None - ephemeralities = EphemeralitySet( + ephemeralities = ResultSet( len_left_core=length_left_core, len_middle_core=length_middle_core, len_right_core=length_right_core, diff --git a/ephemerality/utils.py b/ephemerality/utils.py new file mode 100644 index 0000000..67df450 --- /dev/null +++ b/ephemerality/utils.py @@ -0,0 +1,32 @@ +from pydantic import BaseModel +import numpy as np + + +class ResultSet(BaseModel): + """Class to contain ephemerality and core size values by subtypes""" + len_left_core: int | None = None + len_middle_core: int | None = None + len_right_core: int | None = None + len_sorted_core: int | None = None + + eph_left_core: float | None = None + eph_middle_core: float | None = None + eph_right_core: float | None = None + eph_sorted_core: float | None = None + + def __eq__(self, other) -> bool: + if isinstance(other, ResultSet): + if \ + self.len_left_core != other.len_left_core or \ + self.len_middle_core != other.len_middle_core or \ + self.len_right_core != other.len_right_core or \ + self.len_sorted_core != other.len_sorted_core or \ + not np.isclose(self.eph_left_core, other.eph_left_core) or \ + not np.isclose(self.eph_middle_core, other.eph_middle_core) or \ + not np.isclose(self.eph_right_core, other.eph_right_core) or \ + not np.isclose(self.eph_sorted_core, other.eph_sorted_core): + return False + else: + return True + else: + return False diff --git a/requirements.txt b/requirements.txt index 8cef061..b7645fc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,8 @@ -numpy==1.24.1 -fastapi~=0.89.1 -setuptools==66.0.0 -pydantic==1.10.4 -uvicorn~=0.20.0 +numpy==1.24.2 +fastapi==0.95.0 +setuptools==67.6.1 +pydantic==1.10.7 +matplotlib[test]==3.7.1 +requests[test]==2.28.2 + +ephemerality~=1.0.0 \ No newline at end of file diff --git a/rest/__init__.py b/rest/__init__.py index 23532c2..28e73cc 100644 --- a/rest/__init__.py +++ b/rest/__init__.py @@ -1,10 +1,15 @@ -from api import InputData -from api import get_all_ephemeralities, get_left_core_ephemeralities, get_right_core_ephemeralities -from api import get_middle_core_ephemeralities, get_sorted_core_ephemeralities - +from ephemerality.data_processing import InputData +from rest.api import set_test_mode, router +import rest.api_versions as api_versions +from rest.api_versions import AbstractRestApi __all__ = [ InputData, - get_all_ephemeralities, get_left_core_ephemeralities, get_right_core_ephemeralities, - get_middle_core_ephemeralities, get_sorted_core_ephemeralities + set_test_mode, + router, + AbstractRestApi ] + + +API_VERSION_DICT: dict[str, AbstractRestApi] = {api.version(): api for api in api_versions.__all__ if api.version()} +DEFAULT_API: AbstractRestApi = API_VERSION_DICT[max(API_VERSION_DICT.keys())] diff --git a/rest/api.py b/rest/api.py index 46d92b1..e45852e 100644 --- a/rest/api.py +++ b/rest/api.py @@ -1,55 +1,81 @@ -from fastapi import FastAPI, status -from pydantic import BaseModel -from typing import Any, Sequence -import rest.api11 as api11 -from ephemerality import EphemeralitySet +from fastapi import APIRouter, status, Query, Response +from fastapi.responses import JSONResponse +from typing import Annotated, Any, Union +import sys +import time +import rest +from ephemerality.data_processing import InputData, process_input +from memory_profiler import memory_usage -app = FastAPI() +TEST_MODE = len(sys.argv) > 1 and sys.argv[1] == 'test' +router = APIRouter() -class InputData(BaseModel): - """ - POST request body format - """ - input_sequence: list[str] - input_type: str = 'frequencies' # 'frequencies' | 'f' | 'timestamps' | 't' - threshold: float = 0.8 - range: None | tuple[str, str] = None # used only if input_type == 'timestamps', defaults to (min(timestamps), max(timestamps) + 1) - granularity: None | str = 'day' # used only if input_type == 'timestamps'; ['week', 'day', 'hour'] +def set_test_mode(mode: bool) -> None: + global TEST_MODE + TEST_MODE = mode -@app.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) -async def get_all_ephemeralities(api_version: str, input_data: InputData) -> EphemeralitySet: - if api_version == '1.1': - return api11.get_all_ephemeralities(input_vector=input_data.input_sequence, threshold=input_data.threshold) - else: - raise ValueError(f'Unrecognized API version: {api_version}!') +def run_computations(input_data: list[InputData], core_types: str, api: rest.AbstractRestApi, include_input: bool = False)\ + -> Union[list[dict[str, Any] | dict[str, dict[str, Any]]], None]: + output = [] + for test_case in input_data: + vector, threshold = process_input(input_remote_data=test_case) + case_output = api.get_ephemerality(input_vector=vector, threshold=threshold, types=core_types).dict(exclude_none=True) + if include_input: + output.append({ + "input": test_case.dict(), + "output": case_output + }) + else: + output.append(case_output) + return output -@app.post("/ephemerality/{api_version}/left", status_code=status.HTTP_200_OK) -async def get_left_core_ephemeralities(api_version: str, input_data: InputData) -> EphemeralitySet: - if api_version == '1.1': - return api11.get_left_core_ephemerality(input_vector=input_data['input_vector'], threshold=input_data['threshold']) - else: - raise ValueError(f'Unrecognized API version: {api_version}!') -@app.post("/ephemerality/{api_version}/middle", status_code=status.HTTP_200_OK) -async def get_middle_core_ephemeralities(api_version: str, input_data: InputData) -> EphemeralitySet: - if api_version == '1.1': - return api11.get_middle_core_ephemerality(input_vector=input_data['input_vector'], threshold=input_data['threshold']) - else: - raise ValueError(f'Unrecognized API version: {api_version}!') +@router.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) +async def compute_all_ephemeralities( + input_data: list[InputData], + core_types: Annotated[ + str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") + ]="lmrs", + api_version: str | None = None, + test_time_reps: Annotated[ + int | None, Query(ge=1) + ] = None, + test_ram_reps: Annotated[ + int | None, Query(ge=1) + ] = None, + include_input: bool=True, + explainations: bool=True +) -> Response: -@app.post("/ephemerality/{api_version}/right", status_code=status.HTTP_200_OK) -async def get_right_core_ephemeralities(api_version: str, input_data: InputData) -> EphemeralitySet: - if api_version == '1.1': - return api11.get_right_core_ephemerality(input_vector=input_data['input_vector'], threshold=input_data['threshold']) - else: + if api_version is None: + api = rest.DEFAULT_API + elif api_version not in rest.API_VERSION_DICT: raise ValueError(f'Unrecognized API version: {api_version}!') + else: + api = rest.API_VERSION_DICT[api_version] + + if TEST_MODE and (test_time_reps or test_ram_reps): + output = {} + if test_time_reps: + times = [] + for i in range(test_time_reps): + start_time = time.time() + run_computations(input_data=input_data, core_types=core_types, api=api) + times.append(time.time() - start_time) + output["time"] = times + if test_ram_reps: + rams = [] + for i in range(test_ram_reps): + rams.append(memory_usage( + (run_computations, [], {"input_data": input_data, "core_types": core_types, "api": api}), + max_usage=True + )[0]) + output["RAM"] = rams -@app.post("/ephemerality/{api_version}/sorted", status_code=status.HTTP_200_OK) -async def get_sorted_core_ephemeralities(api_version: str, input_data: InputData) -> EphemeralitySet: - if api_version == '1.1': - return api11.get_sorted_core_ephemerality(input_vector=input_data['input_vector'], threshold=input_data['threshold']) + return JSONResponse(content=output) else: - raise ValueError(f'Unrecognized API version: {api_version}!') \ No newline at end of file + output = run_computations(input_data=input_data, core_types=core_types, api=api, include_input=include_input) + return JSONResponse(content=output) diff --git a/rest/api11.py b/rest/api11.py deleted file mode 100644 index e186497..0000000 --- a/rest/api11.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import Sequence -from ephemerality import compute_ephemerality, EphemeralitySet - - -def get_all_ephemeralities(input_vector: Sequence[float], threshold: float) -> EphemeralitySet: - return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types='all') - -def get_left_core_ephemerality(input_vector: Sequence[float], threshold: float) -> EphemeralitySet: - return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types='left') - -def get_middle_core_ephemerality(input_vector: Sequence[float], threshold: float) -> EphemeralitySet: - return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types='middle') - -def get_right_core_ephemerality(input_vector: Sequence[float], threshold: float) -> EphemeralitySet: - return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types='right') - -def get_sorted_core_ephemerality(input_vector: Sequence[float], threshold: float) -> EphemeralitySet: - return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types='sorted') \ No newline at end of file diff --git a/rest/api_versions/__init__.py b/rest/api_versions/__init__.py new file mode 100644 index 0000000..fd14215 --- /dev/null +++ b/rest/api_versions/__init__.py @@ -0,0 +1,11 @@ +from rest.api_versions.api_template import AbstractRestApi +from rest.api_versions.api11 import RestAPI11 + + +__all__ = [ + AbstractRestApi, + RestAPI11 +] + + + diff --git a/rest/api_versions/api11.py b/rest/api_versions/api11.py new file mode 100644 index 0000000..f22b682 --- /dev/null +++ b/rest/api_versions/api11.py @@ -0,0 +1,19 @@ +from typing import Sequence, Annotated + +from fastapi import Query + +from rest.api_versions.api_template import AbstractRestApi +from ephemerality import compute_ephemerality, ResultSet + + +class RestAPI11(AbstractRestApi): + @staticmethod + def version() -> str: + return "1.1" + + def get_ephemerality(self, + input_vector: Sequence[float], + threshold: Annotated[float, Query(gt=0., le=1.)], + types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] + ) -> ResultSet: + return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types=types) \ No newline at end of file diff --git a/rest/api_versions/api_template.py b/rest/api_versions/api_template.py new file mode 100644 index 0000000..c5b2bfa --- /dev/null +++ b/rest/api_versions/api_template.py @@ -0,0 +1,19 @@ +from abc import ABC, abstractmethod +from typing import Annotated, Sequence +from fastapi import Query +from ephemerality import ResultSet + + +class AbstractRestApi(ABC): + @staticmethod + @abstractmethod + def version() -> str | None: + return None + + @abstractmethod + def get_ephemerality(self, + input_vector: Sequence[float], + threshold: Annotated[float, Query(gt=0., le=1.)], + types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] + ) -> ResultSet: + raise NotImplementedError \ No newline at end of file diff --git a/scripts/ephemerality-api.py b/scripts/ephemerality-api.py new file mode 100644 index 0000000..c757f92 --- /dev/null +++ b/scripts/ephemerality-api.py @@ -0,0 +1,12 @@ +from rest import api +from fastapi import FastAPI +import sys +from rest import set_test_mode, router + + +app = FastAPI() +app.include_router(router) + + +if __name__ == "__main__": + set_test_mode(len(sys.argv) > 1 and sys.argv[1] == 'test') diff --git a/scripts/ephemerality-cmd.py b/scripts/ephemerality-cmd.py index 5768e89..36d506d 100644 --- a/scripts/ephemerality-cmd.py +++ b/scripts/ephemerality-cmd.py @@ -1,12 +1,15 @@ +import time + from _version import __version__ import sys +from typing import Union import json import argparse +from argparse import Namespace import numpy as np -from ephemerality import compute_ephemerality - - -HELP_INFO = "" +from pathlib import Path +from memory_profiler import memory_usage +from ephemerality import compute_ephemerality, process_input def init_argparse() -> argparse.ArgumentParser: @@ -24,66 +27,104 @@ def init_argparse() -> argparse.ArgumentParser: ) parser.add_argument( "-i", "--input", action="store", - help="Path to the input csv file. If not specified, will use the command line arguments " - "(delimited either by commas or spaces)." + help="Path to either a JSON or CSV file with input data, or to the folder with files. If not specified, " + "will read the frequency vector from the command line (delimited either by commas or spaces)." + ) + parser.add_argument( + "-r", "--recursive", action="store_true", + help="Used with a folder --input to specify to also process the files in the full subfolder tree." ) parser.add_argument( "-o", "--output", action="store", - help="Path to the output json file. If not specified, will output ephemerality values to stdout in the" - " following format separated by a space: \"EPH_ORIG EPH_ORIG_SPAN EPH_FILT EPH_FILT_SPAN EPH_SORT " - "EPH_SORT_SPAN\"" + help="Path to the output json file. If not specified, will output ephemerality values to stdout in JSON format." + ) + parser.add_argument( + "-t", "--threshold", action="store", type=float, default=0.8, + help="Threshold value for ephemerality computations in case of CSV input. Defaults to 0.8." ) parser.add_argument( - "-t", "--threshold", action="store", default=0.8, - help="Threshold value for ephemerality computations. Defaults to 0.8." + "--test_time_reps", action="store", type=int, default=0, + help="If greater than 0, the script runs in measure performance mode for the specified number of times and" + " output the computation time instead of ephemerality. Defaults to 0." ) parser.add_argument( - 'frequencies', + "--test_ram_reps", action="store", type=int, default=0, + help="If greater than 0, the script runs in measure performance mode for the specified number of times and" + " output the peak RAM usage instead of ephemerality." + ) + parser.add_argument( + 'frequencies', type=float, help='frequency vector (if the input file is not specified)', nargs='*' ) return parser -def print_ephemeralities(ephemerality_list: list[dict]): - for ephemeralities in ephemerality_list: - print(f"{ephemeralities['ephemerality_original']} {ephemeralities['ephemerality_original_span']} " - f"{ephemeralities['ephemerality_filtered']} {ephemeralities['ephemerality_filtered_span']} " - f"{ephemeralities['ephemerality_sorted']} {ephemeralities['ephemerality_sorted_span']}") - - -if __name__ == '__main__': - parser = init_argparse() - args = parser.parse_args() - - frequency_vectors = list() - - if args.input: - with open(args.input, 'r') as f: - for line in f.readlines(): - if line.strip(): - frequency_vectors.append(np.array(line.split(','), dtype=float)) +def run(input_args: Namespace, supress_save_output: bool = False) -> Union[str, None]: + if input_args.input: + path = Path(input_args.input) + if path.is_dir(): + input_cases = process_input(input_folder=input_args.input, recursive=input_args.recursive) + elif path.is_file(): + input_cases = process_input(input_file=input_args.input) + else: + raise ValueError("Unknown input file format!") else: - if len(args.frequencies) > 1: - frequency_vectors.append(np.array(args.frequencies, dtype=float)) - elif len(args.frequencies) == 1: - if ' ' in args.frequencies[0]: - frequency_vectors.append(np.array(args.frequencies[0].split(' '), dtype=float)) + input_cases: list[tuple[np.ndarray, float]] = [] + if len(input_args.frequencies) > 1: + input_cases.append((np.array(input_args.frequencies, dtype=float), float(input_args.threshold))) + elif len(input_args.frequencies) == 1: + if ' ' in input_args.frequencies[0]: + input_cases.append((np.array(input_args.frequencies[0].split(' '), dtype=float), float(input_args.threshold))) else: - frequency_vectors.append(np.array(args.frequencies[0].split(','), dtype=float)) + input_cases.append((np.array(input_args.frequencies[0].split(','), dtype=float), float(input_args.threshold))) else: sys.exit('No input provided!') - threshold = float(args.threshold) - ephemerality_list = list() - for frequency_vector in frequency_vectors: + for frequency_vector, threshold in input_cases: ephemerality_list.append(compute_ephemerality(frequency_vector=frequency_vector, threshold=threshold).dict()) - if args.output: - with open(args.output, 'w+') as f: + if input_args.output and not supress_save_output: + with open(input_args.output, 'w+') as f: json.dump(ephemerality_list, f, indent=2) - if args.print: - print_ephemeralities(ephemerality_list) + if input_args.print: + return json.dumps(ephemerality_list, indent=2) + else: + return None else: - print_ephemeralities(ephemerality_list) + return json.dumps(ephemerality_list, indent=2) + + +if __name__ == '__main__': + parser = init_argparse() + args = parser.parse_args() + + if args.test_time_reps == 0 and args.test_ram_reps == 0: + output = run(args) + if output: + print(output) + else: + output = {} + if args.test_time_reps > 0: + times = [] + for i in range(args.test_time_reps): + start_time = time.time() + run(input_args=args, supress_save_output=True) + times.append(time.time() - start_time) + output["time"] = times + if args.test_ram_reps > 0: + rams = [] + for i in range(args.test_ram_reps): + rams.append(memory_usage( + (run, [], {"input_args": args, "supress_save_output": True}), + max_usage=True + )[0]) + output["RAM"] = rams + if args.output: + with open(args.output, 'w+') as f: + json.dump(output, f, indent=2) + if args.print: + print(json.dumps(output, indent=2)) + else: + print(json.dumps(output, indent=2)) diff --git a/scripts/test_performance.py b/scripts/test_performance.py new file mode 100644 index 0000000..7c06bcc --- /dev/null +++ b/scripts/test_performance.py @@ -0,0 +1,165 @@ +import json + +from _version import __version__ +import argparse +import os +from subprocess import check_output +import shutil +import requests +from pathlib import Path + +from testing import generate_data + + +def init_argparse() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + usage="%(prog)s [TYPE(s)] [-h] [-v] [-u URL] [-i INPUT_FOLDER] [-r TESTS_PER_CASE] [-g] [-n MAX_TEST_SIZE] " + "[-m CASES_PER_BATCH] [-s SEED] [-k]...", + description="Run performance tests." + ) + parser.add_argument( + "-v", "--version", action="version", + version=f"{parser.prog} version {__version__}" + ) + parser.add_argument( + "-u", "--url", action="store", default="", + help="URL of REST web service. If not provided, will run tests on command line script instead." + ) + parser.add_argument( + "-i", "--input_folder", action="store", default="./test_data/", + help="Path to the folder with test cases. It will be created if it doesn't exist. " + "Will create a \"performance.json\" file for each subfolder (including the root folder) with input files. " + "Defaults to \"./test_data/\"." + ) + parser.add_argument( + "-r", "--tests_per_case", action="store", type=int, default=20, + help="Number of test repetitions per test case per test. Defaults to 20." + ) + parser.add_argument( + "-g", "--generate", action="store_true", + help="Generate test cases using numpy random number generator. Will generate N batches of inputs. Each one " + "will contain M JSON files with thresholds and input vectors, " + "each vector is of length 10^[batch number from 1 to N]. " + "WARNING: will rewrite the contents of the input folder." + ) + parser.add_argument( + "-n", "--max_size", action="store", type=int, default=6, + help="Maximal size (in power 10) of test size batches. Defaults to 6." + ) + parser.add_argument( + "-m", "--cases_per_batch", action="store", type=int, default=20, + help="Number of test cases in each size batch. Defaults to 20." + ) + parser.add_argument( + "-s", "--seed", action="store", type=int, default=2023, + help="Value of the seed to be used for test case generation. Defaults to 2023." + ) + parser.add_argument( + "-k", "--keep_data", action="store_true", + help="Keep generated test data after tests finish. All GENERATED data will be removed otherwise." + ) + parser.add_argument( + 'types', action="store", default="tcr", + help='test types: \"t\" for computation time, \"r\" for RAM usage. Defaults to \"tr\"' + ) + return parser + + + +if __name__ == '__main__': + parser = init_argparse() + args = parser.parse_args() + + if args.tests_per_case <= 0: + raise ValueError("\"tests_per_case\" value should be positive!") + if args.max_size <= 0: + raise ValueError("\"max_size\" value should be positive!") + if args.cases_per_batch <= 0: + raise ValueError("\"cases_per_batch\" value should be positive!") + + # Data + if args.generate: + generate_data( + max_size=args.max_size, + inputs_per_n=args.cases_per_batch, + seed=args.seed, + save_dir=args.input_folder) + else: + if not os.path.exists(args.input_folder): + raise FileNotFoundError("Input folder does not exist and no data generation has been requested!") + elif not os.path.isdir(args.input_folder): + raise NotADirectoryError("Specified input folder is not a directory.") + + + + # Test + + results = {} + if args.url: + if args.url[-1] != '/': + args.url += '/' + if 't' in args.types: + time_results = {} + for json_file in Path(args.input_folder).rglob("*.json"): + with open(json_file, 'r') as f: + test_case = json.load(f) + case_times = [] + for i in range(args.tests_per_case): + response = requests.post(f"args.url?test_time_reps={1}", json=test_case) + case_times.append(response.json()["time"][0]) + time_results[str(json_file.absolute())] = case_times + results["time"] = time_results + if 'r' in args.types: + ram_results = {} + for json_file in Path(args.input_folder).rglob("*.json"): + with open(json_file, 'r') as f: + test_case = json.load(f) + case_rams = [] + for i in range(args.tests_per_case): + response = requests.post(f"{args.url}?test_ram_reps={1}", json=test_case) + case_rams.append(response.json()["RAM"][0]) + ram_results[str(json_file.absolute())] = case_rams + results["RAM"] = ram_results + else: + if 't' in args.types: + time_results = {} + for json_file in Path(args.input_folder).rglob("*.json"): + case_times = [] + for i in range(args.tests_per_case): + run_results = check_output([ + "python", "ephemerality-cmd.py", + "-i", str(json_file.absolute()), + "--test_time_reps", "1" + ]) + case_times.append(json.load(run_results)["time"][0]) + time_results[str(json_file.absolute())] = case_times + results["time"] = time_results + if 'r' in args.types: + ram_results = {} + for json_file in Path(args.input_folder).rglob("*.json"): + case_rams = [] + for i in range(args.tests_per_case): + run_results = check_output([ + "python", "ephemerality-cmd.py", + "-i", str(json_file.absolute()), + "--test_ram_reps", "1" + ]) + case_rams.append(json.load(run_results)["RAM"][0]) + ram_results[str(json_file.absolute())] = case_rams + results["RAM"] = ram_results + + print(results) + + with open('./test_results.json', 'w+') as f: + json.dump(results, f) + + if args.generate and not args.keep_data: + for filename in os.listdir(args.input_folder): + file_path = os.path.join(args.input_folder, filename) + try: + if os.path.isfile(file_path) or os.path.islink(file_path): + os.unlink(file_path) + elif os.path.isdir(file_path): + shutil.rmtree(file_path) + except Exception as e: + print('Failed to delete %s. Reason: %s' % (file_path, e)) diff --git a/setup.py b/setup.py index 3dab15b..37cf640 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ def read(file_name): setup( name='ephemerality', version=version, - packages=['ephemerality', 'test'], + packages=['ephemerality', 'testing'], url='https://github.com/HPAI-BSC/ephemerality', license='MIT', author='HPAI BSC', diff --git a/test/__init__.py b/test/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/test/test_ephemerality.py b/test/test_ephemerality.py deleted file mode 100644 index 2b501fd..0000000 --- a/test/test_ephemerality.py +++ /dev/null @@ -1,510 +0,0 @@ -import warnings -from unittest import TestCase - -from typing import Sequence -import numpy as np -from dataclasses import dataclass -import re - -from ephemerality import compute_ephemerality - - -@dataclass -class EphemeralityTestCase: - input_vector: Sequence[float] - threshold: float - expected_output: dict - warnings: tuple[bool, bool, bool] - - -class TestComputeEphemerality(TestCase): - _warning_messages = [ - re.compile( - r'Original ephemerality value is less than 0 [(]-[0-9]*[.][0-9]*[)] and is going to be rounded up! ' - r'This is indicative of the edge case in which ephemerality span is greater than ' - r'\[threshold [*] input_vector_length], i[.]e[.] most of the frequency mass lies in a few vector ' - r'elements at the end of the frequency vector[.] Original ephemerality in this case should be ' - r'considered to be equal to 0[.] However, please double check the input vector!' - ), - - re.compile( - r'Filtered ephemerality value is less than 0 [(]-[0-9]*[.][0-9]*[)] and is going to be rounded up! ' - r'This is indicative of the edge case in which ephemerality span is greater than ' - r'\[threshold [*] input_vector_length], i[.]e[.] most of the frequency mass lies in a few elements ' - r'at the beginning and the end of the frequency vector[.] Filtered ephemerality in this case should ' - r'be considered to be equal to 0[.] However, please double check the input vector!' - ), - - re.compile( - r'Sorted ephemerality value is less than 0 [(]-[0-9]*[.][0-9]*[)] and is going to be rounded up! ' - r'This is indicative of the rare edge case of very short and mostly uniform frequency vector [(]so ' - r'that ephemerality span is greater than \[threshold [*] input_vector_length][)][.] ' - r'Sorted ephemerality in this case should be considered to be equal to 0[.] ' - r'However, please double check the input vector!' - ) - ] - - _test_cases = [ - EphemeralityTestCase( - input_vector=[1.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 1 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[1.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 1 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[1., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.375, 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0.375, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.375, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[1., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 1 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[0., 1.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 2, - 'ephemerality_filtered': 0.375, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.375, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 1.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 2, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 1 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[.5, .5], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 2, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 2, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 2 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[.5, .5], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 1 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[0.7, .3], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 2, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 2, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 2 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[0.7, .3], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 1 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[1., 0., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.6875, 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0.6875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.6875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[1., 0., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 1 / 6, 'ephemerality_original_span': 1, - 'ephemerality_filtered': 1 / 6, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 1 / 6, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 1.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 4, - 'ephemerality_filtered': 0.6875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.6875, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 1.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 4, - 'ephemerality_filtered': 1 / 6, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 1 / 6, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 1., 0., 1.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 4, - 'ephemerality_filtered': 0.0625, 'ephemerality_filtered_span': 3, - 'ephemerality_sorted': 0.375, 'ephemerality_sorted_span': 2 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 1., 0., 1.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 2, - 'ephemerality_filtered': 1 / 6, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 1 / 6, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[1., 1., 1., 1.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 4, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 4, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 4 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[1., 1., 1., 1.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 2, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 2, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 2 - }, - warnings=(True, True, True) - ), - EphemeralityTestCase( - input_vector=[1., 1., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.375, 'ephemerality_original_span': 2, - 'ephemerality_filtered': 0.375, 'ephemerality_filtered_span': 2, - 'ephemerality_sorted': 0.375, 'ephemerality_sorted_span': 2 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[1., 1., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 1 / 6, 'ephemerality_original_span': 1, - 'ephemerality_filtered': 1 / 6, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 1 / 6, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.875, 'ephemerality_original_span': 1, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 2 / 3, 'ephemerality_original_span': 1, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.375, 'ephemerality_original_span': 5, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 5, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.625, 'ephemerality_original_span': 3, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 3, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.5, 'ephemerality_original_span': 4, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 4, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 8, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 8, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 9, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 9, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 10, - 'ephemerality_filtered': 0.875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.875, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 10, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 8, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 8, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 8 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 3, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 3, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 3 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.125, 'ephemerality_original_span': 7, - 'ephemerality_filtered': 0.5, 'ephemerality_filtered_span': 4, - 'ephemerality_sorted': 0.625, 'ephemerality_sorted_span': 3 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 5, - 'ephemerality_filtered': 2 / 3, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2 / 3, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=np.eye(1, 10000, k=5000).flatten(), - threshold=0.8, - expected_output={ - 'ephemerality_original': 0.375, 'ephemerality_original_span': 5000, - 'ephemerality_filtered': 0.999875, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 0.999875, 'ephemerality_sorted_span': 1 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=np.eye(1, 10000, k=5000).flatten(), - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 5000, - 'ephemerality_filtered': 2999 / 3000, 'ephemerality_filtered_span': 1, - 'ephemerality_sorted': 2999 / 3000, 'ephemerality_sorted_span': 1 - }, - warnings=(True, False, False) - ), - EphemeralityTestCase( - input_vector=np.ones((10000,)), - threshold=0.8, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 8000, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 8000, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 8000 - }, - warnings=(False, False, False) - ), - EphemeralityTestCase( - input_vector=np.ones((10000,)), - threshold=0.3, - expected_output={ - 'ephemerality_original': 0., 'ephemerality_original_span': 3000, - 'ephemerality_filtered': 0., 'ephemerality_filtered_span': 3000, - 'ephemerality_sorted': 0., 'ephemerality_sorted_span': 3000 - }, - warnings=(False, False, False) - ) - ] - - def add_test_case(self, - input_vector: Sequence[float], - threshold: float, - expected_output: dict, - warnings: tuple[bool, bool, bool]): - self._test_cases.append(EphemeralityTestCase( - input_vector=input_vector, - threshold=threshold, - expected_output=expected_output, - warnings=warnings - )) - - def clear(self): - self._test_cases = list() - - @staticmethod - def round_ephemeralities(ephemeralities: dict, precision: int=8): - np.round_(ephemeralities['ephemerality_original'], precision) - np.round_(ephemeralities['ephemerality_filtered'], precision) - np.round_(ephemeralities['ephemerality_sorted'], precision) - - def test_compute_ephemeralities(self): - for i, test_case in enumerate(self._test_cases): - print(f'\nRunning test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') - with warnings.catch_warnings(record=True) as warns: - warnings.simplefilter('always', category=RuntimeWarning) - - actual_output = compute_ephemerality(frequency_vector=test_case.input_sequence, - threshold=test_case.threshold) - - self.assertEqual(self.round_ephemeralities(test_case.expected_output), - self.round_ephemeralities(actual_output)) - - warn_messages = "" - for warn in warns: - warn_messages += str(warn.message) - - actual_warnings = tuple((TestComputeEphemerality._warning_messages[i].search(warn_messages) is not None - for i in range(3))) - - self.assertEqual(test_case.warnings, actual_warnings) diff --git a/testing/__init__.py b/testing/__init__.py new file mode 100644 index 0000000..588b78d --- /dev/null +++ b/testing/__init__.py @@ -0,0 +1,4 @@ +from testing.data_generator import generate_test_case, generate_data + + +__all__ = [generate_test_case, generate_data] diff --git a/testing/data_generator.py b/testing/data_generator.py new file mode 100644 index 0000000..eab53ac --- /dev/null +++ b/testing/data_generator.py @@ -0,0 +1,37 @@ +import json +import os + +import numpy as np + + +def generate_test_case(size: int, seed: None | int=None) -> tuple[float, list[float]]: + vector = np.zeros((size,)) + rng = np.random.default_rng(seed) + threshold = rng.uniform(low=0.1, high=0.9, size=None) + vector[0] = rng.normal(scale=10) + for i in range(1, size): + vector[i] = vector[i-1] + rng.normal() + vector -= np.mean(vector) + vector = vector.clip(min=0) + vector /= np.sum(vector) + + return threshold, list(vector) + + +def generate_data(max_size: int=10, inputs_per_n: int=100, seed: int=2023, save_dir: str= "./test_data/") -> None: + if save_dir and save_dir[-1] != '/': + save_dir += '/' + + for n in range(1, max_size): + dir_n = f"{save_dir}{n}" + os.makedirs(dir_n, exist_ok=True) + + for i in range(inputs_per_n): + test_case = generate_test_case(10**n, seed + i) + test_data = [{ + "threshold": test_case[0], + "input_sequence": test_case[1] + }] + + with open(f"{dir_n}/{i}.json", "w") as f: + json.dump(test_data, f) diff --git a/testing/test_ephemerality.py b/testing/test_ephemerality.py new file mode 100644 index 0000000..8c4bf2e --- /dev/null +++ b/testing/test_ephemerality.py @@ -0,0 +1,670 @@ +from unittest import TestCase +import numpy as np +from testing.test_utils import EphemeralityTestCase +from ephemerality import compute_ephemerality, ResultSet + + +TEST_CASES = [ + EphemeralityTestCase( + input_sequence=[1.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0.375, + eph_middle_core=0.375, + eph_right_core=0., + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.375, + eph_right_core=0.375, + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.5, .5], + threshold=0.8, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.5, .5], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0.7, .3], + threshold=0.8, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0.7, .3], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=4, + len_sorted_core=1, + eph_left_core=0.6875, + eph_middle_core=0.6875, + eph_right_core=0., + eph_sorted_core=0.6875 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=4, + len_sorted_core=1, + eph_left_core=1 / 6, + eph_middle_core=1 / 6, + eph_right_core=0., + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=4, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.6875, + eph_right_core=0.6875, + eph_sorted_core=0.6875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=4, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=1 / 6, + eph_right_core=1 / 6, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1., 0., 1.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=4, + len_middle_core=3, + len_right_core=3, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0.0625, + eph_right_core=0.0625, + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1., 0., 1.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=1 / 6, + eph_right_core=1 / 6, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 1., 1.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=4, + len_middle_core=4, + len_right_core=4, + len_sorted_core=4, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 1., 1.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=2, + len_right_core=4, + len_sorted_core=2, + eph_left_core=0.375, + eph_middle_core=0.375, + eph_right_core=0., + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=1 / 6, + eph_middle_core=1 / 6, + eph_right_core=0, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=10, + len_sorted_core=1, + eph_left_core=0.875, + eph_middle_core=0.875, + eph_right_core=0., + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=10, + len_sorted_core=1, + eph_left_core=2 / 3, + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0.375, + eph_middle_core=0.875, + eph_right_core=0.25, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=3, + len_middle_core=1, + len_right_core=8, + len_sorted_core=1, + eph_left_core=0.625, + eph_middle_core=0.875, + eph_right_core=0., + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=3, + len_middle_core=1, + len_right_core=8, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=4, + len_middle_core=1, + len_right_core=7, + len_sorted_core=1, + eph_left_core=0.5, + eph_middle_core=0.875, + eph_right_core=0.125, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=4, + len_middle_core=1, + len_right_core=7, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=8, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.625, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=8, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=9, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.75, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=9, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=1 / 3, + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=10, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.875, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=10, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=2 / 3, + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], + threshold=0.8, + expected_output=ResultSet( + len_left_core=8, + len_middle_core=8, + len_right_core=8, + len_sorted_core=8, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], + threshold=0.3, + expected_output=ResultSet( + len_left_core=3, + len_middle_core=3, + len_right_core=3, + len_sorted_core=3, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], + threshold=0.8, + expected_output=ResultSet( + len_left_core=7, + len_middle_core=4, + len_right_core=6, + len_sorted_core=3, + eph_left_core=0.125, + eph_middle_core=0.5, + eph_right_core=0.25, + eph_sorted_core=0.625 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], + threshold=0.3, + expected_output=ResultSet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=np.eye(1, 10000, k=5000).flatten(), + threshold=0.8, + expected_output=ResultSet( + len_left_core=5001, + len_middle_core=1, + len_right_core=5000, + len_sorted_core=1, + eph_left_core=0.374875, + eph_middle_core=0.999875, + eph_right_core=0.375, + eph_sorted_core=0.999875 + ) + ), + EphemeralityTestCase( + input_sequence=np.eye(1, 10000, k=5000).flatten(), + threshold=0.3, + expected_output=ResultSet( + len_left_core=5001, + len_middle_core=1, + len_right_core=5000, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2999 / 3000, + eph_right_core=0., + eph_sorted_core=2999 / 3000 + ) + ), + EphemeralityTestCase( + input_sequence=np.ones((10000,)), + threshold=0.8, + expected_output=ResultSet( + len_left_core=8000, + len_middle_core=8000, + len_right_core=8000, + len_sorted_core=8000, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=np.ones((10000,)), + threshold=0.3, + expected_output=ResultSet( + len_left_core=3000, + len_middle_core=3000, + len_right_core=3000, + len_sorted_core=3000, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), + threshold=0.8, + expected_output=ResultSet( + len_left_core=10000, + len_middle_core=10000, + len_right_core=10000, + len_sorted_core=4, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0.9995 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), + threshold=0.3, + expected_output=ResultSet( + len_left_core=2, + len_middle_core=9998, + len_right_core=2, + len_sorted_core=2, + eph_left_core=1499 / 1500, + eph_middle_core=0., + eph_right_core=1499 / 1500, + eph_sorted_core=1499 / 1500 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), + threshold=0.8, + expected_output=ResultSet( + len_left_core=10001, + len_middle_core=10001, + len_right_core=10001, + len_sorted_core=3, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=39989 / 40004 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), + threshold=0.3, + expected_output=ResultSet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=29993 / 30003, + eph_middle_core=29993 / 30003, + eph_right_core=29993 / 30003, + eph_sorted_core=29993 / 30003 + ) + ) +] + + +class TestComputeEphemerality(TestCase): + def test_compute_ephemeralities(self): + for i, test_case in enumerate(TEST_CASES): + with self.subTest(): + print(f'\nRunning test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') + + actual_output = compute_ephemerality(frequency_vector=test_case.input_sequence, + threshold=test_case.threshold) + + try: + self.assertEquals(test_case.expected_output, actual_output) + except AssertionError as ex: + print(f"\tAssertion error while processing test case {i}: {test_case.input_sequence}, " + f"threshold {test_case.threshold}...") + print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") + raise ex diff --git a/testing/test_utils.py b/testing/test_utils.py new file mode 100644 index 0000000..42e1a97 --- /dev/null +++ b/testing/test_utils.py @@ -0,0 +1,10 @@ +from typing import Sequence +from dataclasses import dataclass + +from ephemerality import ResultSet + +@dataclass +class EphemeralityTestCase: + input_sequence: Sequence[float] + threshold: float + expected_output: ResultSet diff --git a/tmp-notebook.ipynb b/tmp-notebook.ipynb index 44ee2df..ded1325 100644 --- a/tmp-notebook.ipynb +++ b/tmp-notebook.ipynb @@ -790,4 +790,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From 9d2441fc0fc6022ca2b39282c955710690c530de Mon Sep 17 00:00:00 2001 From: Dmitry Date: Thu, 13 Apr 2023 21:23:16 +0200 Subject: [PATCH 04/11] Remove temp jupyter notebook --- .gitignore | 2 +- tmp-notebook.ipynb | 793 --------------------------------------------- 2 files changed, 1 insertion(+), 794 deletions(-) delete mode 100644 tmp-notebook.ipynb diff --git a/.gitignore b/.gitignore index f019044..a3f4c77 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,4 @@ /venv/ **/tmp_* **/tmp-* -/testing/test_data/ +/testing/test_data/ \ No newline at end of file diff --git a/tmp-notebook.ipynb b/tmp-notebook.ipynb deleted file mode 100644 index ded1325..0000000 --- a/tmp-notebook.ipynb +++ /dev/null @@ -1,793 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "import matplotlib\n", - "from matplotlib import pyplot as plt\n", - "import matplotlib as mpl\n", - "import numpy as np\n", - "\n", - "plt.style.use('seaborn-v0_8')\n", - "plt.style.use('seaborn-v0_8-poster')\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "outputs": [ - { - "data": { - "text/plain": "['Solarize_Light2',\n '_classic_test_patch',\n '_mpl-gallery',\n '_mpl-gallery-nogrid',\n 'bmh',\n 'classic',\n 'dark_background',\n 'fast',\n 'fivethirtyeight',\n 'ggplot',\n 'grayscale',\n 'seaborn-v0_8',\n 'seaborn-v0_8-bright',\n 'seaborn-v0_8-colorblind',\n 'seaborn-v0_8-dark',\n 'seaborn-v0_8-dark-palette',\n 'seaborn-v0_8-darkgrid',\n 'seaborn-v0_8-deep',\n 'seaborn-v0_8-muted',\n 'seaborn-v0_8-notebook',\n 'seaborn-v0_8-paper',\n 'seaborn-v0_8-pastel',\n 'seaborn-v0_8-poster',\n 'seaborn-v0_8-talk',\n 'seaborn-v0_8-ticks',\n 'seaborn-v0_8-white',\n 'seaborn-v0_8-whitegrid',\n 'tableau-colorblind10']" - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt.style.available" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 85, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[12.8, 8.8]\n", - "17.6\n", - "19.2\n", - "None\n", - "16.0\n", - "16.0\n", - "16.0\n" - ] - } - ], - "source": [ - "print(plt.rcParams.get('figure.figsize'))\n", - "print(plt.rcParams.get('axes.labelsize'))\n", - "print(plt.rcParams.get('axes.titlesize'))\n", - "print(plt.rcParams.get('legend.fontsize'))\n", - "print(plt.rcParams.get('xtick.labelsize'))\n", - "print(plt.rcParams.get('ytick.labelsize'))" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 105, - "outputs": [], - "source": [ - "plt.rcParams.update({'axes.labelsize': 22,'axes.titlesize':32, 'legend.fontsize': 20, 'xtick.labelsize': 20, 'ytick.labelsize': 20})" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 54, - "outputs": [], - "source": [ - "FIG_HEIGHT = 6" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 106, - "outputs": [], - "source": [ - "def compute_left_core_length(frequency_vector: np.array, threshold: float) -> int:\n", - " current_sum = 0\n", - " for i, freq in enumerate(frequency_vector):\n", - " current_sum = current_sum + freq\n", - " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", - " return i + 1\n", - "\n", - "\n", - "def compute_right_core_length(frequency_vector: np.array, threshold: float) -> int:\n", - " current_sum = 0\n", - " for i, freq in enumerate(frequency_vector[::-1]):\n", - " current_sum = current_sum + freq\n", - " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", - " return i + 1\n", - "\n", - "\n", - "def compute_middle_core_range(frequency_vector: np.array, threshold: float) -> tuple[int, int]:\n", - " lower_threshold = (1. - threshold) / 2\n", - "\n", - " current_presum = 0\n", - " start_index = -1\n", - " for i, freq in enumerate(frequency_vector):\n", - " current_presum += freq\n", - " if current_presum > lower_threshold and not np.isclose(current_presum, lower_threshold):\n", - " start_index = i\n", - " break\n", - "\n", - " current_sum = 0\n", - " for j, freq in enumerate(frequency_vector[start_index:]):\n", - " current_sum += freq\n", - " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", - " return start_index, j + 1\n", - "\n", - "def compute_middle_core_length(frequency_vector: np.array, threshold: float) -> int:\n", - " return compute_middle_core_range(frequency_vector, threshold)[1]\n", - "\n", - "\n", - "def compute_sorted_core_length(frequency_vector: np.array, threshold: float) -> int:\n", - " freq_descending_order = np.sort(frequency_vector)[::-1]\n", - "\n", - " current_sum = 0\n", - " for i, freq in enumerate(freq_descending_order):\n", - " current_sum += freq\n", - " if np.isclose(current_sum, threshold) or current_sum > threshold:\n", - " return i + 1\n", - "\n", - "\n", - "def _compute_ephemerality_from_core(core_length: int, range_length: int, threshold: float) -> float:\n", - " return max(0., 1 - (core_length / range_length) / threshold)\n", - "\n", - "def plot_threshold(vector, step: int=0.05, title: str = \"Vector\"):\n", - " fig, axs = plt.subplots(2, 2)\n", - "\n", - " ephemerality_vector = list()\n", - " X = np.arange(step, 1, step)\n", - " for threshold in X:\n", - " ephemerality_vector.append(_compute_ephemerality_from_core(compute_left_core_length(vector, threshold), len(vector), threshold))\n", - " axs[0, 0].plot(X, ephemerality_vector, '.-')\n", - " axs[0, 0].set_xlabel(\"Threshold\")\n", - " axs[0, 0].set_ylabel(\"Ephemerality\")\n", - " axs[0, 0].set_title(rf\"$\\epsilon_l\\left(\\alpha\\right)$ for {title.lower()}\")\n", - " axs[0, 0].set_ylim([0., 1.])\n", - "\n", - " ephemerality_vector = list()\n", - " X = np.arange(step, 1, step)\n", - " for threshold in X:\n", - " ephemerality_vector.append(_compute_ephemerality_from_core(compute_right_core_length(vector, threshold), len(vector), threshold))\n", - " axs[0, 1].plot(X, ephemerality_vector, '.-')\n", - " axs[0, 1].set_xlabel(\"Threshold\")\n", - " axs[0, 1].set_ylabel(\"Ephemerality\")\n", - " axs[0, 1].set_title(rf\"$\\epsilon_r\\left(\\alpha\\right) for {title.lower()}$\")\n", - " axs[0, 1].set_ylim([0., 1.])\n", - "\n", - " ephemerality_vector = list()\n", - " X = np.arange(step, 1, step)\n", - " for threshold in X:\n", - " ephemerality_vector.append(_compute_ephemerality_from_core(compute_middle_core_length(vector, threshold), len(vector), threshold))\n", - " axs[1, 0].plot(X, ephemerality_vector, '.-')\n", - " axs[1, 0].set_xlabel(\"Threshold\")\n", - " axs[1, 0].set_ylabel(\"Ephemerality\")\n", - " axs[1, 0].set_title(rf\"$\\epsilon_m\\left(\\alpha\\right) for {title.lower()}$\")\n", - " axs[1, 0].set_ylim([0., 1.])\n", - "\n", - " ephemerality_vector = list()\n", - " X = np.arange(step, 1, step)\n", - " for threshold in X:\n", - " ephemerality_vector.append(_compute_ephemerality_from_core(compute_sorted_core_length(vector, threshold), len(vector), threshold))\n", - " axs[1, 1].plot(X, ephemerality_vector, '.-')\n", - " axs[1, 1].set_xlabel(\"Threshold\")\n", - " axs[1, 1].set_ylabel(\"Ephemerality\")\n", - " axs[1, 1].set_title(rf\"$\\epsilon_s\\left(\\alpha\\right) for {title.lower()}$\")\n", - " axs[1, 1].set_ylim([0., 1.])\n", - "\n", - " fig.tight_layout()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 127, - "outputs": [], - "source": [ - "def fill(ax, y, x_start, x_end, color):\n", - " x = np.arange(0, len(y))\n", - " ax.fill_between(x, y, -1., where=(x_start <= x) & (x < x_end), color=color)\n", - " ax.fill_between(x, 1., y, where=(x_start <= x) & (x < x_end), hatch='//', facecolor='lightsalmon')" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 131, - "outputs": [], - "source": [ - "def plot_all(vector, ylim, title, threshold, save_path=\"\"):\n", - " title_size = plt.rcParams.get('axes.titlesize')\n", - " plt.rcParams.update({'axes.titlesize': 44})\n", - " plt.figure(figsize=[12.8, FIG_HEIGHT])\n", - " plt.plot(vector, '.-', color='#912916')\n", - " plt.ylim(ylim)\n", - " plt.xlabel(\"Time\")\n", - " plt.ylabel(\"Normalized activity\")\n", - " plt.title(title, fontweight='bold')\n", - " plt.tight_layout()\n", - " if save_path:\n", - " plt.savefig(f\"{save_path}{title}.png\", bbox_inches='tight')\n", - "\n", - " plt.rcParams.update({'axes.titlesize': title_size})\n", - "\n", - " left_core = compute_left_core_length(vector, threshold)\n", - " right_core = compute_right_core_length(vector, threshold)\n", - " middle_core = compute_middle_core_range(vector, threshold)\n", - " sorted_core = compute_sorted_core_length(vector, threshold)\n", - "\n", - " ephemeralities = {\n", - " \"left_core\": _compute_ephemerality_from_core(left_core, len(vector), threshold),\n", - " \"right_core\": _compute_ephemerality_from_core(right_core, len(vector), threshold),\n", - " \"middle_core\": _compute_ephemerality_from_core(middle_core[1], len(vector), threshold),\n", - " \"sorted_core\": _compute_ephemerality_from_core(sorted_core, len(vector), threshold),\n", - " }\n", - "\n", - " fig, axs = plt.subplots(2, 2)\n", - " fig.set_figheight(FIG_HEIGHT + 1)\n", - " axs[0, 0].plot(vector, '.-', color='#912916')\n", - " fill(axs[0, 0], vector, 0, left_core, color='coral')\n", - " axs[0, 0].set_ylim(ylim)\n", - " axs[0, 0].set_xlabel(\"Time\")\n", - " axs[0, 0].set_ylabel(\"Activity\")\n", - " cur_title = rf\"${int(threshold * 100)}\\%$ left core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['left_core'], 2)}$\"\n", - " axs[0, 0].set_title(cur_title)\n", - "\n", - " axs[0, 1].plot(vector, '.-', color='#912916')\n", - " fill(axs[0, 1], vector, len(vector) - right_core, len(vector), color='coral')\n", - " axs[0, 1].set_ylim(ylim)\n", - " axs[0, 1].set_xlabel(\"Time\")\n", - " cur_title = rf\"${int(threshold * 100)}\\%$ right core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['right_core'], 2)}$\"\n", - " axs[0, 1].set_title(cur_title)\n", - "\n", - " axs[1, 0].plot(vector, '.-', color='#912916')\n", - " fill(axs[1, 0], vector, middle_core[0], middle_core[0] + middle_core[1], color='coral')\n", - " axs[1, 0].set_ylim(ylim)\n", - " axs[1, 0].set_xlabel(\"Time\")\n", - " axs[1, 0].set_ylabel(\"Activity\")\n", - " cur_title = rf\"${int(threshold * 100)}\\%$ middle core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['middle_core'], 2)}$\"\n", - " axs[1, 0].set_title(cur_title)\n", - "\n", - " sorted_vector = np.sort(vector)[::-1]\n", - " axs[1, 1].plot(sorted_vector, '.-', color='#912916')\n", - " fill(axs[1, 1], sorted_vector, 0, sorted_core, color='coral')\n", - " axs[1, 1].set_ylim(ylim)\n", - " axs[1, 1].set_xlabel(\"Sorted activity vector\")\n", - " cur_title = rf\"${int(threshold * 100)}\\%$ sorted core\" + \"\\n\" + rf\"Ephemerality: $\\epsilon={np.round(ephemeralities['sorted_core'], 2)}$\"\n", - " axs[1, 1].set_title(cur_title)\n", - "\n", - " fig.tight_layout()\n", - "\n", - " if save_path:\n", - " plt.savefig(f\"{save_path}{title} with cores.png\")\n", - "\n", - " return ephemeralities" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [], - "source": [ - "one_peak_vector = np.array([1,2,7,5,2,4,5,3,10,5,6,45,98,287,261,150,29,11,2,8,5,3,3,5,6,2], dtype=float)\n", - "one_peak_vector /= np.sum(one_peak_vector)\n", - "# print(len(one_peak_vector))\n", - "# plt.plot(one_peak_vector, '.-', color='#912916')\n", - "# plt.ylim([0,0.31])" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 132, - "outputs": [ - { - "data": { - "text/plain": "{'left_core': 0.3162393162393162,\n 'right_core': 0.4017094017094017,\n 'middle_core': 0.7008547008547008,\n 'sorted_core': 0.7435897435897436}" - }, - "execution_count": 132, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAABNgAAAIvCAYAAACm8WbnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAADQsUlEQVR4nOzdd3hURdsG8Ht303sC6QkhVCEJHUKRJqARKQIiGIogoLxC7FIUUREFC1IERQQFQhHpTTqEIhA6QRIIhJpKSE9I2WTP9wdf1mzK7ia7my25f9fF9TLnzJl5FnJe4pOZeUSCIAggIiIiIiIiIiKiGhHrOwAiIiIiIiIiIiJjxgQbERERERERERGRBphgIyIiIiIiIiIi0gATbERERERERERERBpggo2IiIiIiIiIiEgDTLARERERERERERFpgAk2IiIiIiIiIiIiDTDBRkREREREREREpAEm2IiIiIiIiIiIiDRgpu8AiIiISP+Kiopw9+5dJCQkICUlBfn5+SgoKIBYLIalpSUcHR1Rv359+Pn5wcfHBxKJRN8hExEREREZDCbYiIiI6qiHDx9i7969OH78OK5fv47CwkK1nrOxsUHr1q3Ro0cP9O/fHx4eHhrF8dxzzyEhIaHK+1OnTkVYWJhGc9BTkZGRGDt2rNI+R44cgY+PTy1FRKQa/z+CiIiMARNsREREdUxMTAx++uknHDlypEbPP3nyBGfOnMGZM2fwww8/oG/fvnj33XfRuHFjLUdKRERERGQceAYbERFRHVFcXIyFCxdi2LBhNU6ulVdSUoIDBw5g8ODBWLZsGWQymVbGJSIiIiIyJkywERER1QEFBQV4++23sXz5cpSUlGh9fKlUiiVLluDdd99FUVGR1scnIiIiIjJkTLARERHVAdOmTcPx48d1Ps/Bgwcxc+ZMnc9DRERERGRImGAjIiIycevXr8eBAwdqbb49e/Zg48aNtTYfEREREZG+scgBERGRCcvKysKSJUvU6uvp6YmePXvimWeegaurK2xtbVFYWIjMzEzExsbi5MmTiI2NVWusH3/8ES+99BIcHBw0CZ+IiIiIyCgwwUZERGTCtm7diszMTKV9fH19MWPGDPTp0wcikajKftOmTcPp06cxa9YsJCQkKB0zOzsbf/75J958882ahE1EREREZFSYYCMiIjJhu3fvVnrfx8cHmzdvhrOzs1rjde3aFevXr8fw4cORmpqqtO+ePXvUSrAdPXpUrbmJiIiIiAwVz2AjIiIyUbm5ubhx44bSPhMmTFA7uVbK09MTn3zyicp+sbGxSE9Pr9bYRERERETGiAk2IiIiE5WQkACZTKa0j6+vb43GfuGFF+Dp6am0jyAIuHPnTo3GJyIiIiIyJtwiSkREZKLy8vJU9rl9+za6d+9e7bElEgl69uyJP//8U2k/VdtIDcGtW7dw48YNPH78GEVFRXBxcUG9evXQsmVLeHh46Gze7OxsREVF4cGDB8jOzoZYLIaLiwuaNWuGgIAASCQSnc2taw8fPsTNmzeRlJSEvLw8iEQi2NjYwMPDA/7+/mjUqBHEYuP+Oe+dO3cQExODR48eIT8/H7a2tvD29kZQUBDc3d11OndBQQH+/fdf3L9/HxkZGSgqKoKlpSWcnJzg7e2Nli1b6rzAiEwmQ3x8PG7duoX09HTk5eXhyZMnkEgksLS0hK2tLdzc3ODp6YlGjRrBzIz/2UFERKaN/9IRERGZKCcnJ5V9Vq5ciRdeeAFeXl7VHn/UqFF45plnlPZp0aKFynGee+45pUUTpk6dirCwsBqPUb9+ffzzzz8K19LS0hAeHo4dO3YgKSmpynFbtmyJkJAQvPbaa1pJWMhkMvz999/YtGkTLly4UOUKQxcXFwwZMgRvvPEG6tevL7++c+dOTJs2rcrx1fmz0pX4+Hhs2LAB+/btQ2JiotK+9vb26NmzJwYPHozu3bsrLa6hS9u2bcPMmTOrvD9z5kyMGzdO3n7y5Ak2btyIv/76C/fu3avyuRYtWmD48OEYPnw4LCwstBJrSUkJDhw4gK1btyIyMhJSqbTKviKRCM888wxeeOEFDB8+XOFrSBNSqRQHDx7E/v37cerUKTx58kSt56ytrdG6dWsMGDAAAwYMgLW1tVbiqY6YmBiMHj0aubm5SvvZ2trijz/+QOvWrWspMiIiMhVMsBEREZkodVbRPH78GK+++ipmzpyJF198sVqripo1a4ZmzZppEqJebNiwAQsWLFD5H9oAEB0djejoaPz++++YNWsWBg4cWON5o6Ki8OmnnyI2NlZl3/T0dKxatQqbN2/Gp59+ipdffrnG8+paTk4OFi1ahD///BPFxcVqP7Nnzx7s2bMHzZs3x6efforg4GAdR6qZY8eOYfbs2Xj06JHKvjExMZgzZw5WrVqFOXPm4Nlnn9Vo7n/++Qdz5sxRmtQrSxAExMTEICYmBj///DNGjx6NKVOmwM7OrsYxHD9+HN98843aMZSVn5+Ps2fP4uzZs1i8eDGmT5+u0btUXQ8fPsSkSZNUvvNWVlb49ddfmVwjIqIaMe61+URERFQlW1tbNG3aVGW/1NRUfPDBB3j++eexdOlSxMXF1UJ0ta+oqAgffPABvvzyS7WSa2VlZmbio48+wooVK2o096ZNmxAaGqpWcq2s7OxsTJ8+Hd9++22N5tW1mJgYvPzyy1i3bp3aybXybt68iddffx3ffvstSkpKtByhdixduhSTJ09WK7lWVkJCAiZOnIhffvmlRvOWlJTg22+/xRtvvFGjxBbw9Ov+999/x5AhQxATE1OjMVasWIG33nqrxjGUlZqaio8++ghffvklBEHQeDxV0tPTMXHiRJXb1S0sLLBs2TJ07NhR5zEREZFpYoKNiIjIhIWEhKjd9+HDh/jpp5/Qv39/9OvXD19++SUOHDiAtLQ0HUZYO6RSKcLCwrB3716Nxvnxxx9x4cKFaj0THh6O2bNnK93Sp8rvv/+OH3/8scbP68KFCxcwevRoxMfHazyWIAj4/fff8f7772v056QLv/zyC3766acaPy8IAhYtWoQFCxZU67ni4mJ8+OGH+P3332s8d1kPHjzAqFGjcO7cuWo9t3btWixYsEDrybANGzbg119/1eqY5T158kStxKCZmRkWLlyo8UpDIiKq25hgIyIiMmFDhw6FlZVVtZ978OABNmzYgHfeeQddu3ZF//798cUXX2Dfvn3Izs7WQaS69dVXXyEiIkLjcQRBwJdffql2/0uXLmH+/PkazwsAv/76K/bt26eVsTQVFxeHyZMnV3sloCoHDhzAnDlztDqmJs6cOYPFixdrZawVK1Zg//79avefM2eO1v++8/Ly8L///U/tVar//vsvvvvuO63GUNayZcuQnp6uk7GLi4vx7rvvIioqSmk/sViMb7/9Fn379tVJHEREVHcwwUZERGTCvLy88NZbb2k8TlxcHDZu3Ij33nsPXbp0wejRo7F69epqb5nTh7S0NGzatElr48XGxuLy5csq+2VnZ+PDDz+s8dbJyhw7dkxrY9VUUVER3n33XeTk5Ohk/L/++stgEokRERFaXbk1a9YstVb87dy5U6tfs2Xl5ubigw8+UOvr8ttvv9XpisKioiIcOHBAJ2PPmjULJ06cUNpHJBLhq6++woABA3QSAxER1S0sckBERGTiJk6ciBMnTqiVFFJHcXExzp8/j/Pnz+O7775Dt27dMG7cOHTr1k0r42tbZQmSBg0aoH///mjZsiVsbGyQnJyMEydO4PDhw1VW9izr4MGDaNu2rdI+a9asUVlNs1SbNm3Qr18/NGzYEObm5khOTsY///yDo0ePGtyWyZUrV+LWrVsq+zVv3hzPP/88mjVrBltbW2RlZeHatWvYs2ePysTs119/jd69e9do9aUuiUQidOvWDT179oS3tzckEgkePnyII0eO4MyZMyqfz8nJwY8//qh0u29OTg6++eYblWNZWVnhhRdeQMeOHeHu7g6ZTIb4+HicOHECJ06cUJoYvHHjBtatW6dQIbW8yMhIldtJRSIRunTpgueeew7u7u6ws7PDkydPkJSUhMuXL+PQoUMoKipSOsbly5fx2muvKe1TXQsWLMD27dtV9vv000/xyiuvaHVuIiKqu5hgIyIiMnEWFhZYsWIFxowZgxs3bmh17JKSEvl/0Ldr1w6ff/45nnnmGa3OoU0WFhaYNm0aQkNDIZFIFO4NHz4cFy5cwOTJk1WuzlJ1WHxRURH+/PNPlfHY2dlh3rx5eP755yvcGzFiBOLi4jB9+nRcu3ZN5Vi1IScnB6tWrVLax87ODl988UWlVSL79++P999/Hz///LPSg/9TU1OxefNmjBkzRuOYtcXX1xc//PAD2rRpU+HemDFjcPbsWXz00UcqD9M/cOAAkpKS4OnpWen91atXIzMzU+kYPXv2xDfffIP69etXuDd69GhER0fjww8/xJ07d6ocY+XKlQgNDYWFhUWl93fs2KE0BltbW6xYsQIdOnSo9P6YMWMQFxeHUaNGISMjo8pxtFE4oax169apVYzkww8/NKivLyIiMn7cIkpERFQHODg44I8//kCnTp10NselS5fwyiuvYMOGDTqbQxMSiQQ///wzxowZUyG5VqpDhw74/PPPVY6lamXa/v378fjxY6V9LC0tsWbNmkqTa6UaN26MtWvXqlwtV1t27dql9Nw1MzMz/Prrr5Um10pZWFjgvffewwcffKB0rs2bN9c4Tm3z8/PDpk2bKk2ulercuTM2btwIFxcXpWMVFxdj/fr1Vd5TtTW0Z8+e+OWXXypNrpVq2bIlwsPDq0ziAU+TmMrOJczOzoaTk1OV9z///PMqk2ulGjdujDfffFNpH21uM9+3bx++/vprlf3+97//qYyLiIiouphgIyIiqiNcXFywZs0azJ49G87OzjqZQyqV4ssvv8Ty5ct1Mr4mRo0ahe7du6vsN2DAAHh7eyvtk5WVpfS+OtsF33vvPQQGBqrsZ2Njgx9++AE2NjYq++ra33//rfT+sGHDVCZdSk2cOBENGjSo8v7NmzfVPoxfl8RiMRYsWIB69eqp7Ovr66tWEYyqzgY7f/680hVwZmZm+PLLL6tMEJdVv359vPPOO0r7KDvrbtmyZYiMjMSJEyfw22+/4aOPPsLAgQPRvHlzPPPMMxg0aJDKGACgY8eOSu9r6yy/yMhITJs2TeUW73HjxuG9997TypxERERlMcFGRERUh4jFYowaNQpHjx7Fp59+ikaNGulknoULF6pMxtS2sWPHqtVPJBKpXDH25MkTpfcvXbqk9L6dnR1GjhypVjwA4OPjo3ZCQ1dyc3NVnuP30ksvqT2eRCJBnz59lPZRJ1Gpaz169EBQUJDa/Z9//nk0btxYaZ9bt25VuhLw5MmTSp9r166d0lVp5fXr1w9icdXf7p89e1ZlEQd3d3f06NEDkyZNwg8//IBdu3Zh586dEIlEasWgbBUcABQWFqo1jjKxsbGYMmWKyvPeRowYgZkzZ2o8HxERUWWYYCMiIqqDbGxsMHbsWOzbtw+bN2/G+PHj4efnp9U5Zs+erXKbZG3x8vKCr69vtforo6wCY2ZmpspzpXr16lXtFWn6TrBdv34dJSUlSvs0bNiwWmOq+juJioqq1ni6oGy7a02fkclklSYrVZ21V9131N7eHo6OjlXeT09PV6uqaU08evQIO3bsULmiTxtFPA4ePKhyJZyNjQ1mzJih8VxERERVYZEDIiKiOq5Vq1Zo1aoVZsyYgYcPH+Ls2bM4e/Yszp07p9H5SDk5OVi+fDlmzZqlxWhrprqJHwcHB6X3lW1DS05OVjm+OltDywsICICZmZnS5J4uqbNds0ePHlqdU51qpbrWunXraj/TqlUrlX0qO8dP1Z/x5s2btX42XWxsbLWSz5UpKChAbGwsoqOjcfXqVVy+fBl3797VUoTa8eTJE6xatQphYWH6DoWIiEwUE2xEREQk5+vrC19fXwwfPhwAcPfuXZw5cwZnz57F6dOnq31e0rZt2zBt2rQqKxXWFldX12r1t7W1rfFcqs5nA1Sv3KqMlZUVvLy88ODBg5qEpbGUlJRan1NVMQldE4vF8PHxqfZz6my9Lv91UlRUhPT09GrPpanq/hkLgoDbt2/j3LlziIqKwr///ou7d++qXN1oCFauXIkhQ4bU6O+UiIhIFSbYiIiIqEr+/v7w9/dHaGgoSkpKcP78eezYsQN79uxRa2tXXl4eTp8+jV69euk+WCVUrUgrz8ys5t8iZWdnq+xjZ2dXo7Ht7e1r9Jw2qPO5tC0zMxNFRUV6S9Da2dmpfdZYWer8PZVPsOXm5qo8D00XlBVVKCsqKgrbt2/H4cOHtVr5szYVFBRg/vz5WLp0qb5DISIiE8Qz2IiIiEgtEokEnTt3xvz587F//36V1QFL/fvvvzqOTDVra+tq9dckwaaqAIIm41taWtboOW3QxmH0NVFZMYDaUpPkGqDe11v5P09D/fONi4vDuHHjMHz4cGzYsMFok2ulDh06hH/++UffYRARkQniCjYiIiITlp2djdTUVKSlpeHx48fy/y0uLsbHH39c43F9fHzw+++/Y/Dgwbhz547SvoZwFpNEIqm1udTZXlrTpJE+k01WVlZ6mVdVZUhdqumftzpJ1vKrGPWVPFWW2IuIiMB7772H/Pz8ao0pFovRpEkTtGvXDk2bNsVXX32laZhaNXfuXOzatQvm5ub6DoWIiEwIE2xEREQmaMaMGSq3cU6YMAEuLi41nsPCwgJvvfUWpk+frrRfdc9t04XaTLCpsz2wpmdt6bMqq6pttiKRCNHR0RCLTWeDRElJCdLT06v9nqiTmHNyclJoq7ONeerUqbV2SP+1a9cwdepUtbaC16tXDx06dECrVq0QGBiIwMBAeQIxPj6+VhNs3t7eGDlyJBYsWFBlnzt37iA8PBxvvPFGrcVFRESmjwk2IiIiE+Tu7q7yP4xPnz6NAQMGaDTPM888o7KPMRx+rk3169dX2efGjRvVHjc+Pl4vh+CXKp8QKk8QBGRlZcHZ2bl2AqolN27cQNeuXav1jDqrNssn1MzMzGBnZ6c0OZeZmVmtOGqqpKQEM2fOVPr/IWKxGK+88gqGDx+OoKCgKrfT1ub77+npiTVr1sDX1xdHjhzBlStXquy7dOlSDBw4sNoFUIiIiKpiOj9iJCIiIrnAwECVfbZu3arxPOps33N0dNR4HmPSsGFDlWdwnTt3rtrjnjx5sqYhaUXjxo1V9omOjq6FSGrX+fPnq/2MOn8OlVUabdKkidJnrl+/Xu1YaiIiIgK3bt2q8r5IJMLChQvx1VdfoVWrVkrPqquts+Xc3NzkyTUA+OSTT5TGlZeXh++//75WYiMiorqBCTYiIiIT1Lp1a5Vb9c6cOYOrV69qNM/Zs2dV9mnQoIFGcxgbiUSicmVfTExMtZJRMpkM69at0zQ0jbRq1Upln2PHjqk9nkwmw2effYaff/4ZBw8eRFxcHIqLizUJUSe2b98OmUxWrWf279+v9L6lpSVatmxZ4XpQUJDS5/79999qbRM+fPgw5s6diz///BMXLlxARkaG2s8p06tXL4SEhKg1Vlpamlr9NFG/fn2sWbMGfn5+8mutW7fGwIEDlT63a9cuXLp0SdfhERFRHcEtokRERCbIzc0NnTt3xunTp6vsIwgCPv/8c/z55581OsA+MzMTa9euVdmvbdu21R7b2D377LO4fPmy0j5z587FunXr1Dqz7Oeff8bt27e1FV6NODo6okmTJkrj2Lp1K9566y21tt2dOnUKf/31l8I1c3Nz+Pn5oXHjxmjSpAmee+45tVZj6lJSUhLWrVuHsWPHqtX/4sWLuHbtmtI+AQEBsLCwqHC9ffv2CA8Pr/I5qVSKVatWqTz3sNRvv/1WYZuki4sLmjRpgsaNG6Np06Z47bXXKnwN3rx5U+m4zZo1U2t+QL0qwoIg1LhiKwCMHDmy0hWBH330EQ4fPlxl0QlBEDB37lxs2bLFpM4OJCIi/eC/JERERCZq2LBhKvvExMTgnXfeqXaVwLy8PEydOhWpqalK+zk5OaFLly7VGtsUDB48WGXC4OLFi5g1a5bKM6rWrFmDZcuWaTO8Ghs8eLDS+0+ePMGHH36ocuuwVCrFokWLKr1++/ZtHDhwAMuWLUNeXp4m4WrNggUL1FrplJmZiU8++URlv+eee67K66qKHaxevVqt7cIHDx6s9Ayy9PR0nDt3Dhs3bsT+/fsrTSypKtLw4MEDlfMDQH5+PjZu3Kiyn65WLrq7u2PChAlK+1y/fr1CopeIiKgmmGAjIiIyUc8//zy8vb1V9jt+/DhefvllnDx5EoIgKO0rCAJOnjyJoUOHqnU21dChQytdqWPqfH190blzZ5X9tm7dipEjR+Ls2bMK2xAFQcClS5cwceJEfPPNN9XeoqgrQ4YMgZmZ8g0QkZGReOONN5CQkFDp/YKCAsyYMUPleWKNGjVCcHBwjWPVpoKCArzxxhvYtm1ble9IbGwsRo8ejXv37ikdy8bGBq+++mql9ywtLVVua5TJZHj77bexadOmKr8uzp07p1ai77XXXqv0uqok3+HDh1WuqCwoKMD7779f5ddBWbo8p23ixInw9PRU2mfhwoW1VkCCiIhMF7eIEhERmSgLCwt89tlnmDx5ssq+9+7dw8SJE9GwYUN069YNAQEBcHZ2hrW1NfLy8vD48WPExMTgn3/+wcOHD9Wa38HBAW+++aamH8Noffzxx3jllVdUJseioqLw+uuvw8nJCT4+PhAEAQkJCQb5H/yurq549dVXsWHDBqX9zp8/j5CQELzwwgvo0qUL3NzcUFxcjOvXr2Pbtm1qJV3eeecdbYWtFfn5+Zg5cyb++OMP9O/fH40bN4aVlRVSUlJw8uRJHDlyRK2VWEOGDFFa+KM0kadsVWlRURFmz56N8PBwhISEoHnz5rC1tUVKSgqOHTuGQ4cOqfy6a968OV544YVK7/n4+Cjd5iqVSjFx4kQsXrwYrVu3VrgnCAKOHTuG77//Hnfu3FEaQ6m8vDzY2dmp1be6rKys8NFHH+HDDz+ssk9mZiYWL16Mzz//XCcxEBFR3cAEGxERkQnr3bs3XnzxRezbt0+t/vfu3VO5AkddM2bMgLOzs1bGMkYBAQEYPnw4Nm3apFb/zMxMlUk1kUikcpWhrr3//vs4ePCgysP2i4qKsHv3buzevbvacwQHB+PFF1+saYg6FRsbi9jY2Bo96+bmhrCwMKV9fHx88Pbbb2PBggUqx7t165bSap/KzJo1CxKJpNJ7vXr1Uvn/GUlJSXj11VfRoUMHBAYGwtLSEklJSTh//jySkpKqFcvjx4/h7u5erWeqY8CAAVi3bp3ScxE3bdqEESNGqCxQQkREVBVuESUiIjJx8+bNQ4cOHWp1zldffVWtM+BM3cyZM6t1ILwyw4YNg5ubm1bG0oSDgwPmzp2rs0PhXV1d8d133+lk7JpQtSVWXWKxGN9//71aSefx48ejXbt2Wpm3MpMnT0anTp2qvN+vXz+1ClUAwIULF7B69Wr8+uuv2LVrV7WTa4D6Z7pp4pNPPlF6LmJJSQm++uorncdBRESmiwk2IiIiE2dtbY0VK1bo9D/Yyxo+fDi+/PLLWpnL0FlbW+O3335DgwYNNBqnV69e+OKLL7QTlBb07t0bs2fP1qjyY2VsbW2xdOlSeHh4aHVcTXz//fdVrvSqjmnTpql1Lh/wtJrqsmXLtJacLat///547733lPaxtbXFjBkztDanj4+P0vsXL17U2lxVadWqlcoiHRcuXKjRiksiIiKACTYiIqI6wdbWFmvXrsW7776rs6IDNjY2mDNnjk5XNxkjDw8PbNiwAe3bt6/R80OHDsVPP/2k1t9bbf65v/baa1i0aJHWzs7y9PTEhg0b0KZNG62Mpy39+/fHTz/9BGtr6xo9b2Zmhi+++ALjx4+v1nMuLi7YsGEDevToUaN5KzNu3DgsWLBArcTogAEDVG5nVcXMzAzTpk3D4sWLlfY7fvy4RvOo64MPPoCNjY3SPt99953BVK8lIiLjwu9+iYiI6ghzc3O8/fbb2LFjBwYMGABLS0utjGtpaYnRo0dj//79GDFihFbGNDWurq4IDw/HrFmzUK9ePbWe8fb2xuLFizFv3jy1k6Lm5uaahFltISEh2L17N0JCQmq8mk0ikSA0NBQ7d+402POv+vTpg02bNqFp06bVeq5x48ZYv359ldU6VbG3t8dvv/2Gr7/+WqNVfQ0bNsSKFSswc+bMaiVhp06dinnz5qlMSlWmZcuW2LBhAyZMmIDAwECl8T948KBWVrG5u7tj0qRJSvs8evQIv/zyi85jISIi08MiB0RERHVM48aNsWDBAmRlZWH37t04efIkrl+/jtTUVLXHcHd3R5s2bfDcc8+hb9++OqsAaEokEgnGjBmDESNG4PDhwzh+/Diio6ORlJSEJ0+ewNLSEh4eHggKCkLfvn3x3HPPVTj/S1WBA12tTlTGy8sLixcvRlxcHLZv345Dhw6pVSjD29sbAwYMwLBhw+Dn56f7QDXUvHlzbN++HX/99RfWrl2r9DO2bt0aI0eOxODBg7WyvfSVV17BoEGDcPDgQezevRvnzp3DkydPlD5jYWGBzp07Y+jQoejbt2+Nk69Dhw5Ft27dsH79emzbtk3p/0/Y2dkhODgYQ4cOxXPPPaeQzAsJCcHq1aurfDY8PLzGqzyrY8KECdiyZYvSSrarV6/GsGHD4O/vr/N4iIjIdIgEfZeiIiIiIoOQkpKCW7duITs7Gzk5OcjJyUFhYSEsLS1hbW0NJycneHp6wtfXV+0D0Em7unTpgvT09Crvz5s3D0OHDq3FiCqXnp6O2NhYxMfHIysrC4WFhbCwsICDgwPc3NwQEBBgEF9D27Ztw8yZM5X2uXnzZqXX4+LiEB0djeTkZEilUtja2sLX1xetWrVC/fr1dRGuXElJCW7duoUHDx4gJSUFT548gUwmg52dHRwdHdG4cWM0a9ZMJysa7969i5iYGKSnpyMnJwc2NjaoV68evL29ERQUpLWiEERERMaG/wISERERgKer0tzd3fUdBimRk5Oj9L6Tk1PtBKKCi4uL2gf6G6vGjRujcePGeplbIpHgmWee0cuWWn9/f67sIiIiqgQTbERERERaduLECXzxxRfw9vaGp6cnvLy85L9K29U9NL90pZQyXl5emoRNRERERDXEBBsRERGRlllaWiIhIUHpOU/Ozs748ssv8cILL6g15t69e5XeF4vFaNiwYXXCJCIiIiItYRVRIiIiIi1T53yxjIwMbNmyRa3xbt++jeXLlyvt06JFC1hZWak1HhERERFpFxNsRERERFrm4+MDe3t7lf1OnDiBL7/8Eo8ePar0fnx8PFasWIGRI0ciOztb6Vjdu3evUaxEREREpDluESUiIiLSMgsLC/Tt2xfbt29X2XfDhg3YuHEjvL294erqCrFYjPz8fCQmJiIzM1Ot+cRiMYYNG6Zh1ERERERUU0ywEREREenAhAkTsGfPHpWFCQBAEATEx8cjPj6+RnMNGjQIDRo0qNGzRERERKQ5bhElIiIi0oGmTZti0qRJOp+nfv36mD59us7nISIiIqKqMcFGREREpCPvvPMOXnnlFZ2N7+TkhBUrVsDFxUVncxARERGRakywEREREemISCTCV199halTp8LMTLsnc7Rr1w6bN29GQECAVsclIiIioupjgo2IiIhIh8RiMcLCwrB37168+uqrsLW11Wi89u3bY8mSJdiwYQPPXSMiIiIyECJBEAR9B0GaS03N0XcIGhOLRahXzw4AkJaWC5mMX5pEleG7QqQeQ31XpFIpoqKu4N9/o3Dnzm0kJiYgPT0dOTk5KCwsgEwmg5mZGSwtLeHo6ARXVzc0aOCHli0D0KFDZ3h4eOj7I5CJMdR3hciQ8D0hUo8pviuurvZq9WMVUSIiIqJaZG5ujvbtO6J9+476DoWIiIiItIRbRImIiIiIiIiIiDRgEivYbt68iZUrVyIyMhLp6elwcnJCYGAgQkND0aNHjxqPe/bsWaxbtw5XrlxBZmYmnJ2dERAQgGHDhqFfv35KnxUEATt37sSWLVsQExMDqVQKDw8P9OzZE2+88QY8PT1rHBcRERERERERERkOoz+D7ciRI3j33XchlUorvT9mzBjMmjWr2uPOmzcPq1evrvJ+7969sWTJElhYWFS4J5PJ8NFHH2Hv3r2VPmtvb4+lS5eic+fO1Y6rKjyDjaju4LtCpB6+K0Tq4btCpBrfEyL1mOK7ou4ZbEa9RTQ6OhoffPABpFIpgoKCEB4ejrNnz2LLli3o27cvACA8PBzr16+v1rjh4eHy5FqXLl0QHh6O06dPY+fOnQgNDQUAHDt2DHPmzKn0+YULF8qTa+PHj8f+/ftx+vRpLFq0CJ6ensjJyUFYWBiSk5Nr+MmJiIiIiIiIiMhQGPUKtrfeegsRERHw8/PD9u3bFcreC4KA9957D/v374eTkxOOHDkCOzs7lWMWFBSgZ8+eyMzMRPv27REeHg6JRKLQZ+7cufLrR48eVajmlZKSgj59+kAqlWLSpEn46KOPFJ5NSEjA0KFDkZmZiVdffRVfffWVhn8KT3EFG1HdwXeFSD18V4jUw3eFSDW+J0TqMcV3xeRXsMXFxSEiIgLA00Rb2eQaAIhEIsyYMQNisRiZmZk4dOiQWuOeP38emZmZ8nHLJ9cAYNCgQQCAkpIS/Pvvvwr31q1bB6lUChsbG0yePLnCs97e3hg3bhwAYPfu3cjPz1crLiIiIiIiIiIiMkxGm2A7efIkgKeJtN69e1fax9PTEy1atAAAHD58WK1xu3fvjn/++Qdr1qxBly5dVPY3NzdXaB8/fhwAEBwcXOWKuT59+gAA8vPz8c8//6gVFxERERERERERGSajTbDFxMQAALy8vODi4lJlv5YtWwIArl+/rvbY9evXR+fOnSstYCAIAsLDwwEAtra2aNOmjfyeVCpFXFwcACAwMLDK8Zs2bSpPzFUnLiIiIiIiIiIiMjxm+g6gphISEgAAPj4+Svt5eXkBAJKTk1FcXAwzs+p/5MLCQjx69Aj//vsvwsPDcfHiRQDAzJkz4ejoKO9XOoequEQiETw9PfHgwQPEx8dXO57KiMUirYyjT2U/gyl8HiJd4btCpB6+K0Tq4btCpBrfEyL11OV3xWgTbBkZGQCgkOCqjL3908PoBEFAdna20tVuVfnss8+wc+dOedvBwQHff/89evXqVWlMpX3UiSs7O7va8VSm9BBBU+HsbKu6ExHxXSFSE98V05V0+Twy79+Bk18jeLbtqO9wjB7fFSLV+J4QqaeuvStGm2ArLCwEAFhaWirtZ2VlJf99UVFRjeZKTExUaGdnZ2PevHkoLi5G3759Kx2/7LyVKY279HMQERERkfpyEuOx553xSI2Okl9zbdkKA5b8AXsv5TsciIiIiLTNaBNslVX31JW5c+fC09MThYWFOHXqFH744Qfcu3cPYWFhWLhwIUJCQgAAYrH+jrRLS8vV29zaIhaL5BnujIw8kyjnS6QLfFeI1MN3xbTte3ss0mMVz7JNjY7CzrfH4sVVu/QUlXHiu0KkGt8TIvWY4rui7o5Bo02wWVtbA1C9Kq2goED+e1Wr3arSsGFD+fP9+/dH+/btMWTIEKSlpeG7775Dnz59YG5uDhsbG/kzqlamld5XtdJNXabwRVuWTCaY3Gci0gW+K0Tq4btiWlL/vVQhuVYqPfY6UqIuwjWwXS1HZRr4rhCpxveESD117V0x2iqipWeY5eTkKO1XesaZRCJReV6butzd3TFmzBgAT4st3LhxQyGm6sTl7OyslZiIiIiI6oqc+HtK7z+6fLZ2AiEiIiL6f0abYPP39wdQ8Xy08pKSkgA8TYppcwtnQECA/PellUA9PT3lK9KUxSUIApKTk+XPEBEREZH67H0aKr1/fe3PSPjnSO0EQ0RERAQjTrA1a9YMAPDw4UPk5lZ9/lh0dDQAoEWLFmqNu2XLFowZMwbDhw9X2q/sFtDSpJpYLEbjxo0V5q1MbGwspFIpAKBly5ZqxUVERERET7kGtoNz04Aq75cUFeDEp5NxPfxnCELd2ZpCRERE+mO0CbaePXsCAEpKShAREVFpn6SkJMTExAAAunfvrta4ubm5OHfuHKKiohAVFVVlv5MnTwIARCKRQpKsNK6zZ8/iyZMnlT579OhRAICFhQU6deqkVlxERERE9J+2Uz5R3kEQELXyR5ye8x6KC/JrJygiIiKqs4w2webr64v27dsDAH766acKZ54JgoD58+dDJpPB2dkZgwcPVmvckJAQmJubAwB++OEHlJSUVOhz4cIFbNu2DQDQq1cvuLu7y+8NGjQIEokEWVlZWLp0aYVnExMTsXr1agDAsGHD4ODgoFZcRERERPSfopwshbZHpx7o+e1KmNsqVvp6cHQvDoeNRN4j5ceKEBEREWnCaBNsADBz5kyIxWLcu3cPoaGhOHXqFNLT03H9+nWEhYVh//79AICwsDCFCp/A00RaSEgIpk2bpnDdw8MDb775JgAgMjISo0ePxunTp5GWlob79+9j+fLlmDBhAqRSKZydnfHpp58qPO/v74/Q0FAAwKpVqzB79mzExcUhPT0dBw4cwKhRo5CZmQknJyf5PERERERUPVn3bim03dt2hlfnXuj38xbYefsp3MuIvY6Dbw3F438v1WaIREREVIeIBCM/mGLbtm347LPPUFxcXOn98ePHY8aMGRWuN2/eHADQqVMnhIeHK9wTBAFz587FunXrqpzX29sby5Ytq/Rst8LCQrzzzjtVbl21sbHB77//jrZt21Y5fnWlpiqvWmoMxGIR6tV7+lPntLTcOlXOl6g6+K4QqYfvimn758v38ODoHnm7x/zf4N2lN4Cnq9v++eIdJF/4R+EZsbk5On7wFRr1f6VWYzV0fFeIVON7QqQeU3xXXF3t1epnpuM4dG7o0KEICAjAqlWrEBkZibS0NNjY2CAwMBChoaHo27dvtccUiUT47LPP8MILL2D9+vW4dOkSMjIyYG1tjSZNmuD555/HiBEjKqyKK2VpaYnly5djx44d2LZtG27cuIH8/Hy4ubnh2WefxaRJk+Dr66vpRyciIiKqs8qvYHNs2FT+ewt7R/T8dhWuLP8WNzf/Ib8uk0oR+e0MZN65iTaTp0NsZvTfChMREZGBMPoVbPQUV7AR1R18V4jUw3fFdMmKi7E5JAiy/6/KbmZtg1f+vgKRuOLpJ3f+3oLzP34m71vKo+Oz6Pb5YljYO9ZKzIaM7wqRanxPiNRjiu+KuivYjPoMNiIiIiKqe3IT7iskzBz8mlSaXAOARv1fwXOL1sPKpb7C9eTzp3Bw8jBk3but01iJiIiobmCCjYiIiIiMirLtoZVxDWyH53/dBudmAQrXc+Lv4dDbryDxbIS2QyQiIqI6hgk2IiIiIjIqWXfLJdj8lSfYAMDWzQt9f/oTDZ57SeG6NC8Xx2dMQszG38CTU4iIiKimmGAjIiIiIqNS3RVspcysrNF19iK0mviB4g1BwJXl3+Ls1x+hpLBQW2ESERFRHcIEGxEREREZlQoJNjVWsJUSiUQIGPM2un+zHGbWtgr37h3aiSPvhuLJ4xStxElERER1BxNsRERERGQ0ZMVS5Dy8J2+b2djCxs2z2uP4dOuL53/ZDDsvX4XraTFXcfDNIUiLuappqERERFSHMMFGREREREYjJ/4eZMX/VRB1bNgEIpGoRmM5+jfD88u3wa1tZ4Xr+WmPcPid13D34A5NQiUiIqI6hAk2IiIiIjIaFQocqHn+WlUsHZ3R+4c/0HTIGIXrsqIinP36I1z+5VvISko0moOIiIhMHxNsRERERGQ0alrgQBmxmTk6vPc5On40F2Izc4V7N/78DSc/eQtFuTkaz0NERESmiwk2IiIiIjIaFVawVaPAgSpNBo5E7x/XwtLRWeF64tkIHPzfMGQ/vKu1uYiIiMi0MMFGREREREZDFyvYynJr3REvrNgBpyYtFK7nPLiDg5OHIen8Sa3OR0RERKaBCTYiIiIiMgol0iLkxN+Xt81t7WDt6qH1eWw9vNFv6Sb49nxB4bo0NxvHp03Ajb9+hyAIWp+XiIiIjBcTbERERERkFHIe3oNQUixvOzZsWuMKoqqYWdug2xc/IWj8uwrXBZkMl5d9g8j5M1BSVKiTuYmIiMj4MMFGREREREZB19tDyxOJxQgcF4Znv1oGiZW1wr27+7fi6HujkZ+WqtMYiIiIyDgwwUZERERERqF8gQMHLRY4UMa3xwvot+wv2Hp4K1x/fP0yDr41BOk3/62VOIiIiMhwMcFGREREREYh+37trmAry7lJCzz/6za4tu6ocP1JajIOTx2B+0f21FosREREZHiYYCMiIiIio5B197ZC27GWVrCVsnKqh94L1qDJoNcUrpcUFeL0nPdw9bcFEGSyWo2JiIiIDAMTbERERERk8EqKCpGTcE/eNrezh3U9t1qPQ2JugY4ffoUO738JkcRM4V70ul9w8tPJkObl1HpcREREpF9MsBERERGRwXtaQbRE3tZlBVF1NH15FHr/8AcsHJ0VriecPoqDbw9HTsJ9PUVGRERE+sAEGxEREREZvNquIKoO93Zd8MLyrXD0b6ZwPfvebRx8ayiSL57WU2RERERU25hgIyIiIiKDVyHBVsvnr1XFzqsB+v38F3ye7adwvSgnCxEfj0fstrVIvXYRd/ZvQ+q/l/QUJREREemameouRERERET6lXXX8FawlTK3scOzXy3DtT+W4PrapfLrQkkJLi6eo9DXuVkAus/9BbbuXrUdJhEREekQV7ARERERkcEz1BVspURiMVpNeA/dPl8MiaVVlf0yYq/j5Kz/1WJkREREVBuYYCMiIiIig1ZSWIjcMkUDLOwdYeXiqseIqtbguZfQd+kmWDrXq7JPRux1bhclIiIyMUywEREREZFBy354B4JMJm/ru4KoKi7NAhAw+m2lfXLi79VOMERERFQrmGAjIiIiIoNW4fw1A9seWhmXZ4KU3rf3aVg7gRAREVGtYIKNiIiIiAxahfPXDKjAQVVcA9vBuVlApfdcmgfCNbBdLUdEREREusQEGxEREREZtPIJNgcjWMEGAN3n/lIhGSiSSNDty6VVPEFERETGigk2IiIiIjJoFbaIGsEKNgCwdfdC/zX7YOPqIb8mlJSgKDtTf0ERERGRTjDBRkREREQGq7iwALmJD+RtC0dnWCmp0GmIfHq8oNBOjDyup0iIiIhIV5hgIyIiIiKDlX0/DhAEeduxYRODriBaGa/OPRXaSUywERERmRwm2IiIiIjIYBljgYPy3FoHQ2JpJW+nRV9BIbeJEhERmRQm2IiIiIjIYFVIsBlJgYOyJJaWcG/bWd4WZDIknz+lx4iIiIhI25hgIyIiIiKDlW2kBQ7K8wzuodDmOWxERESmhQk2IiIiIjJYprCCDQA8g8udw3buBASZTE/REBERkbYxwUZEREREBqm4IB+5SfHytqWTC6ycjKuCaCl7bz/Y+zSUtwsz0pBxK1p/AREREZFWMcFGRERERAapYgVR41y9Vqr8KjZuEyUiIjIdTLARERERkUHKKn/+mpFuDy3l1bncNlEm2IiIiEwGE2xEREREZJAqnL9m5CvY3FoHQ2JpJW+nRV9BYXam/gIiIiIirWGCjYiIiIgMkqkUOCglsbSEe9vO8rYgkyH5/Ck9RkRERETawgQbERERERmkCltE/ZroKRLt8QzuodDmOWxERESmwUzfAWjDzZs3sXLlSkRGRiI9PR1OTk4IDAxEaGgoevTooXqAKly+fBkbNmzAxYsXkZqaCjMzM3h5eaFbt254/fXX4e3tXelzgiCgY8eOyMnJUTnHpUuXYGtrW+MYiYiIiExRcf4T5CWXqSDqXA+WTi56jEg7yhc6SDp3AoJMBpGYP/cmIiIyZkb/L/mRI0cwbNgw7Nq1CykpKZBKpUhNTcWxY8cwadIkzJ07t0bjfv/99xg5ciR27dqFhIQEFBUV4cmTJ7h9+zbWrFmDAQMG4PDhw5U+++DBA7WSa0RERERUuaz7cQptYz9/rZS9tx/sfRrK24UZaci4Fa2/gIiIiEgrjHoFW3R0ND744ANIpVIEBQVh2rRpaNq0KeLj47F8+XIcPnwY4eHh8Pf3x6hRo9Qed926dVi5ciUAoEOHDnj77bfRokULZGZm4ty5c1i4cCEyMzPx/vvv46+//kKLFi0Unr9+/ToAwNzcHCdPnoSFhUWVc3H1GhEREVFFplbgoCzP4J7Iib8nbydGHodL80D9BUREREQaM+oVbIsXL0ZBQQH8/PywZs0adOrUCc7OzggKCsLSpUsREhICAFiyZAlyc3PVGrOoqAhLliwBAHTq1Alr1qxBt27d4OLigkaNGmHkyJHYunUrHBwcUFRUhEWLFlUYozTB1qxZMzg7O8PW1rbKX0RERERUUYXz14y8wEFZXp3LbRPlOWxERERGz2gTbHFxcYiIiAAAvPXWWxWSVSKRCDNmzIBYLEZmZiYOHTqk1rhnzpxBVlYWACAsLAxmZhUX+fn4+GD48OEAgH/++QdSqVThfnT002X+gYH8SSQRERFRTWSb8Ao2t9bBkFhaydtp0VdQmJ2pv4CIiIhIY0abYDt58iSAp4m03r17V9rH09NTvn2zqvPSyktKSoKNjQ0AoHXr1lX28/PzAwBIpVJkZGQo3CtNsLVq1UqtOYmIiIhIUYUtoia0gk1iaQn3tp3lbUEmQ/L5U3qMiIiIiDRltAm2mJgYAICXlxdcXKquKNWyZUsA/23bVGXkyJG4fPkyLl68CEtLyyr73b9/X/57BwcH+e/j4+ORmZkJAHB1dcX8+fMREhKCwMBAdOzYEWPHjsWuXbsgCIJa8RARERHVNdInechLTpC3rVxcYengpL+AdMAzWLHSfSK3iRIRERk1oy1ykJDw9JsuHx8fpf28vLwAAMnJySguLq50y2dl7OzsqryXn5+PXbt2AQACAgJgZfXfEv/S1WsAMGXKFIXto1KpFJGRkYiMjMTu3buxaNEirZ3DJhaLtDKOPpX9DKbweYh0he8KkXr4rhivnAeKFUSd/Jua3N+hd5deuLh4jrydfO4ERBAgEtf+z7/5rhCpxveESD11+V0x2gRb6bZMR0dHpf3s7e0BAIIgIDs7W+lqN3V9++23SE1NBYAK1UnLrpRzdHTElClT0L17d9ja2uLGjRv45ZdfcO7cOZw4cQIff/wxfv75Z43jAYB69apOCBojZ2cWgCBSB98VIvXwXTEuKakPFNruLVqa3Pc69eoFwMmvETLv3wEAFGSkQfboLtwCqj6ipDbwXSFSje8JkXrq2rtitFtECwsLAUDpNk4ACqvLioqKNJ539erV2LhxIwCgQ4cOGDJkiML9vLw82Nvbw8PDA9u2bUNoaCh8fX3h4uKCrl27YvXq1ejXrx8A4MiRIzh27JjGMRERERGZkrTbNxXa9Zo011MkuuXX/TmF9r2TR/QUCREREWnKaFewSSSSWp9z9erVmDdvHgDA3d0dP/74I8TllvHPmjULs2bNQlFRESwsLCqMIZFIMHv2bEREREAqlWLr1q1VFmmojrS0XI3H0DexWCTPcGdk5EEm4zl1RJXhu0KkHr4rxis5RvHsXIlrA5P4Xqc8lzbdgHUr5e3bRw+h8fA3az0OvitEqvE9IVKPKb4r6q6iN9oEm7W1NQDVq9IKCgrkv1e12q0qgiBgwYIF+O233wA8LV7wxx9/wN3dvcpnKkuulXJzc0NQUBAuXbqEq1ev1iim8kzhi7YsmUwwuc9EpAt8V4jUw3fFuGTdVawg6uDX1CT//lxbdYLE0golhU+/X02LvoL8zAy9FnTgu0KkGt8TIvXUtXdFoy2iERERKCkp0VYs1VJ6tlpOTo7SftnZ2QCerhxTdV5bZQoKCvDuu+/Kk2s+Pj5Yv349GjduXO2xyiotvlB6lhwRERERAdK8HDx5lCRvW9d3h4W9g5InjJfE0hLubTvL24JMhuTzp/QYEREREdWURgm2yZMno3v37pg7dy6ioqK0FZNa/P39AQCJiYlK+yUlPf0Gzd3dvcJ2TlXS09Px+uuv48CBAwCeVgzdtGkT/Pz8VD4rCMqztKXVRUtX4hERERERkHXvtkLbsWETPUVSOzyDeyi0EyOP6ykSIiIi0oTGRQ7S09Oxfv16jBgxAiEhIfjll18QHx+vjdiUatasGQDg4cOHyM2t+kyO6OhoAECLFi2qNX5KSgpGjhyJK1euAAB69+6NdevWoX79+lU+k5ycjOeeew5t2rTB0qVLlY5/+/bTbx4bNmxYrbiIiIiITFnWPcXtoY7+TfUUSe3wDO6p0E46dwKCTKanaIiIiKimNEqwff311+jSpQtEIhEEQcC9e/ewZMkS9OvXD6Ghodi0aZN8i6a29ez59JuRkpISREREVNonKSkJMTExAIDu3burPXZGRgbGjRuH+/fvAwBGjBiBZcuWwcbGRulzrq6uyMrKQn5+Pk6cOFFlv+joaMTFxQEAevToUWU/IiIiorqm/Plrjg1NO8Fm7+0He5+G8nZhRhoybkXrLyAiIiKqEY0SbMOGDcMff/yBiIgIzJgxAy1btoQgCBAEAZcvX8YXX3yBZ599FlOnTsWhQ4fk2yK1wdfXF+3btwcA/PTTTxXOYhMEAfPnz4dMJoOzszMGDx6s9tiffvop7ty5AwAYO3Ys5syZo1bVUolEgpdeegkAEBUVhR07dlTok5eXh1mzZgEAbG1tMXLkSLXjIiIiIjJ1FVawmXiCDQA8O/dSaHObKBERkfHReIso8LQq5rhx47Bt2zbs27cPb7/9Nnx9fSEIAoqKinDkyBG88847ePbZZ/H555/j4sWL2pgWM2fOhFgsxr179xAaGopTp04hPT0d169fR1hYGPbv3w8ACAsLq7D6LCQkBCEhIZg2bZrC9WPHjuHIkSMAgLZt2+Kdd95BXl6e0l9lz1ubMmUKnJycAACzZs3C4sWLcevWLaSnp+Po0aMYOXIkrl9/Wnr+k08+gaurq1b+LIiIiIhMQfkEm0MdSLB5lTuHLYkJNiIiIqMjElSdxq+Bq1evYs+ePTh69CgSEhKeTigSAQC8vb0xaNAgDBo0SKNzyLZt24bPPvsMxcXFld4fP348ZsyYUeF68+bNAQCdOnVCeHi4/Pq4ceNw5syZasVw5MgR+Pj4yNtRUVF4++23kZqaWml/c3NzfPzxx3j99derNY8yqanKq6kaA7FYhHr17AAAaWm5daqcL1F18F0hUg/fFeNTlJONrQPayds2rh4YvMX0q2qWFBZi68D2KCksAACIxGIM2XkOlg5OtTI/3xUi1fieEKnHFN8VV1d7tfppZQVbVVq3bo1PP/0UR44cwe7duzF27FhIJBIIgoCEhAT88ssvePHFFzF69Gjs3bsXshoc6Dp06FBs27YNgwcPhoeHB8zNzeHo6Ihu3bph2bJllSbXlLl69Wq1YyivVatW2LNnD8LCwhAQEAAbGxtYWlqiQYMGGDFiBLZv367V5BoRERGRKci6r1hB1MHECxyUklhawr1tZ3lbkMmQfN70E4tERESmxEzXE8TGxuLo0aM4duwYrl27Jt9OWXbh3IULF3Dx4kUsX74c33zzDYKCgqo1R/PmzfHdd99V65mbN29Wev3y5cvVGqcqTk5OmDp1KqZOnaqV8YiIiIhMXdbdWIV2XTh/rZRncA8kno2QtxMjj8OvzwD9BURERETVopME28OHD7Fnzx7s3btXXi2zNKFmbm6OXr16YfDgwWjVqhUOHTqEbdu24fr167h16xbGjh2L8PBwBAYG6iI0IiIiIjJQWfcUV7DVrQRbT4V20rkTEGQyiMQ63XBCREREWqK1BFtqair+/vtv7N27F9euXZNfL02stW7dGoMHD8ZLL70ER0dH+f1Ro0Zh1KhRWL16NebPn4+CggIsXLgQq1at0lZoRERERGQEsu6WryDaRE+R1D57bz/Y+zRETvw9AEBhRhoybkXDpTl/6ExERGQMNEqwZWdn48CBA9i7dy/Onz8vP0OtNKnm5eWFQYMG4eWXX1ZZyGDcuHEIDw9HQkKCVs5BIyIiIiLjkn2v7ibYAMCzcy/kbFktbydGHmeCjYiIyEholGDr2rUrSkpKAPyXVLO1tcULL7yAl19+GZ06darWeG5ubkhISICZmc6PhiMiIiIiA1KUk4X8tEfyto2bJ8xt1avaZSq8gnsgtkyCLSnyOALHTtFfQERERKQ2jTJZxcXFAACJRIIuXbrg5ZdfRr9+/WBpaVmj8SQSCTp37owuXbpoEhYRERERGZmK20PrzvlrpdxaB0NiaYWSwgIAQFr0FRRmZ8LSwUm/gREREZFKGiXYmjVrhpdffhkDBw6Eq6urxsGsW7dO4zGIiIiIyPhUKHDgX/cSbBJLS7i37SyvJirIZEg+f4rVRImIiIyARmWJdu3ahTfeeKNGybWCggLcvXtXk+mJiIiIyERkVTh/re4l2ADAM7iHQjsx8rieIiEiIqLq0CjB1qdPH/Tt2xenT5+u1nP79u1Du3btMH78eE2mJyIiIiITUSHBVgdXsAGAZ3BPhXbSuRMQ/r+QGBERERkujRJsCQkJSEhIQH5+frWflclkePz4sSbTExEREZGJKH8Gm4Nf3aogWsre2w/2Pg3l7cKMNGTcitZfQERERKQWtc5gS0tLQ2FhYZX309PTkZiYqHIcmUyG7OxsrF+/HsDTiqNEREREVLcVZmeiID1V3rb18Ia5Td39PtGzcy/klKkmmhh5HC7NA/UXEBEREamkVoLt4MGDmDNnToXrIpEIADB79uxqTywSidCqVatqP0dEREREpoUVRBV5BfdAbJkEW1LkcQSOnaK/gIiIiEgltbaIvvbaa2jXrh0EQdDaLwcHB3z00Ue6/nxEREREZODKn7/mUMcTbG6tgyGxtJK306KvoDA7U38BERERkUpqrWADgHnz5mHXrl0K15YuXQqRSIQXX3wRjRo1UjmGSCSCtbU1PDw80LVrVzg5OVU7YCIiIiIyLRVWsNXRAgelJJaWcG/bGYlnIwAAgkyG5POn4NdngH4DIyIioiqpnWBr0KABpk6dqnBt6dKlAICXXnoJffr00W5kRERERFQnVKggWsdXsAGAZ3APeYINeHoOGxNsREREhkvtBFtlShNu6qxeIyIiIiKqTIUEm19jPUViODyDeyq0k86dgCCTQSRW64QXIiIiqmVaSbAREREREdVEYWY6CjPS5G1bT1+YWdvoMSLDYO/tB3ufhsiJvwcAKMxIQ8ataFYTJSIiMlD8ERgRERER6U3F7aFN9BSJ4fHs3EuhnRh5XD+BEBERkUpqrWArPV9NJBLh8OHDFa7XVPnxiIiIiKhuYYGDqnkF90DsltXydlLkcQSOnaK/gIiIiKhKaiXYEhISADxNiJW/LhKJIAhCjSYvPx4RERER1S0scFA1t9bBkFhaoaSwAACQFn0FhdmZsHRw0m9gREREVIFaCTYvL69qXSciIiIiUkeFBBtXsMlJLC3h3razvJqoIJMh+fwpVhMlIiIyQGol2I4ePVqt60RERERE6lDYIioSwaEBK4iW5RncQ55gA56ew8YEGxERkeFhkQMiIiIi0ouCjDQUZmXI23ZevjCzstZjRIbHM7inQjvp3AkIMpmeoiEiIqKqaJRgmzNnDi5fvqytWIiIiIioDsm6G6vQ5vlrFdl7+8He11/eLsxIQ8ataD1GRERERJXRKMG2YcMGhIaGok+fPli4cCFiY2NVP0REREREBBY4UFf5VWyJkcf1FAkRERFVReMtooIgICEhAStWrMDgwYMxcOBArFixQl55lIiIiIioMll3byu0HRo20VMkhs0ruIdCO4kJNiIiIoOjUYJt3759CAsLQ5MmTSAIAgRBwK1bt7Bw4UL07dsXoaGh2LhxIzIyMlQPRkRERER1ClewqcetdTAkllbydlr0FRRmZ+ovICIiIqpAowSbv78/pkyZgj179mD37t343//+Bz8/P3my7fLly5gzZw66d++ON998E7t27UJ+fr62YiciIiIiIyUIgkKCTSQWw8GPFUQrI7G0hHvbzvK2IJMh+fwpPUZERERE5WmtimjTpk3x7rvv4sCBA9i+fTsmTZoEb29vCIKA4uJinDx5EtOnT0fXrl3xwQcf4OjRoyguLtbW9ERERERkRArSH6OozCosW09fmJVZpUWKPMttE+U5bERERIbFTBeDtmjRAi1atMCHH36Ia9eu4e+//8ahQ4cQHx+P/Px87Nu3D/v27YOjoyPOnj2rixCIiIiIyIBV2B7qz+2hypQvdJB07gQEmQwisdZ+Xk5EREQa0Pm/yEFBQZg+fToOHz6MH374Ae7u7gD+f1tAVpaupyciIiIiA5R1l+evVYe9tx/sff3l7cKMNGTcitZjRERERFSWTlawlRIEAefOncOhQ4cQEREhrywqCAIAwMPDQ5fTExEREZGBYoGD6vMM7omch3fl7cTI43BpHqjHiIiIiKiU1hNspUm1/fv349ChQ0hLS5NfBwBHR0c8//zzGDhwIDp27Kjt6YmIiIjICHCLaPV5BfdA7JbV8nZS5HEEjp2iv4CIiIhITisJNlVJNUtLS/Tu3RsDBgxAz549YW5uro1piYiIiMgICYKA7Hu35W2RWAwH30Z6jMg4uLUOhsTSCiWFBQCAtOgrKMzOhKWDk34DIyIiIs0SbJGRkVUm1SQSCTp37owBAwagX79+sLOz0zxaIiIiIjJ6BempKMr57yxeO28/SCwt9RiRcZBYWsK9bWckno0AAAgyGZLPn4JfnwH6DYyIiIg0S7C9/vrrEIlE8qQa8LSowcCBA9G/f3/Ur19f4wCJiIiIyLSwwEHNeQb3kCfYgKfnsDHBRkREpH8abxEVBAENGzbEgAEDMHDgQPj5+WkjLiIiIiIyUTx/reY8g3sqtJPOnYAgk0EkFuspIiIiIgK0sIJt4MCBCAxk9SIiIiIiUg9XsNWcvbcf7H395dVECzPSkHErmtVEiYiI9EyjH3XNnDmTyTUiIiIiqpYKK9iYYKuW8qvYEiOP6ykSIiIiKsW15ERERERUawRBUEiwiSQS2Ps21F9ARsgruIdCO4kJNiIiIr1Ta4vo2LFjAQAikQhr1qypcL2myo9HRERERKYt/3EKpLk58ra9d0NILFhBtDrcWgdDYmmFksICAEBa9BUUZmfC0sFJv4ERERHVYWol2M6dOweRSKT2dXUIglDjZ8u7efMmVq5cicjISKSnp8PJyQmBgYEIDQ1Fjx49VA9QhcuXL2PDhg24ePEiUlNTYWZmBi8vL3Tr1g2vv/46vL29q3xWEATs3LkTW7ZsQUxMDKRSKTw8PNCzZ0+88cYb8PT0rHFcRERERMaqYoGDJnqKxHhJLC3h3razvJqoIJMh+fwpVhMlIiLSI7W3iAqCUOX1mvzSliNHjmDYsGHYtWsXUlJSIJVKkZqaimPHjmHSpEmYO3dujcb9/vvvMXLkSOzatQsJCQkoKirCkydPcPv2baxZswYDBgzA4cOHK31WJpPhww8/xPTp03H+/Hnk5uaisLAQ9+/fx9q1azFw4ECcPXtWk49NREREZJRY4EA7PMttE+U5bERERPql1gq2GzduVOt6bYmOjsYHH3wAqVSKoKAgTJs2DU2bNkV8fDyWL1+Ow4cPIzw8HP7+/hg1apTa465btw4rV64EAHTo0AFvv/02WrRogczMTJw7dw4LFy5EZmYm3n//ffz1119o0aKFwvMLFy7E3r17AQDjx4/HiBEj4ODggHPnzuHbb79FUlISwsLCsHv3bnh4eGjvD4SIiIjIwLHAgXaUL3SQdO4EBJkMIjGPWCYiItIHo/4XePHixSgoKICfnx/WrFmDTp06wdnZGUFBQVi6dClCQkIAAEuWLEFubq5aYxYVFWHJkiUAgE6dOmHNmjXo1q0bXFxc0KhRI4wcORJbt26Fg4MDioqKsGjRIoXnU1JS8McffwAAJk2ahBkzZsDf3x/16tXDiy++iPXr18PJyQnZ2dlYtmyZ9v4wiIiIiIxAhRVs/kyw1YS9tx/sff3l7cKMNGTcitZjRERERHWbRgm2HTt2YMeOHUhOTq7Wc3FxcViwYAHmzJlT47nj4uIQEREBAHjrrbdga2urcF8kEmHGjBkQi8XIzMzEoUOH1Br3zJkzyMrKAgCEhYXBzKziIj8fHx8MHz4cAPDPP/9AKpXK761btw5SqRQ2NjaYPHlyhWe9vb0xbtw4AMDu3buRn5+vVlxERERExk4QBGTfvy1viyRmsPNpqL+AjFz5VWzcJkpERKQ/GiXYZsyYgZkzZ+L69evVeu7WrVv47bffsHPnzhrPffLkSQBPE2m9e/eutI+np6d8+2ZV56WVl5SUBBsbGwBA69atq+zn5+cHAJBKpcjIyJBfP3786Tc2wcHBsLOzq/TZPn36AADy8/Pxzz//qBUXERERkbF7kpoEad5/uwrsfRtCYm6hx4iMm1e5c9iSmGAjIiLSG71sEU1MTAQAhZVf1RUTEwMA8PLygouLS5X9WrZsCQBqJwFHjhyJy5cv4+LFi7C0rLpk/P379+W/d3BwAPD088TFxQEAAgMDq3y2adOmMDc3r1ZcRERERMaOBQ60y611MCSWVvJ2WvQVFGZn6i8gIiKiOkytIgfbtm3D+fPnq7wfHh6u1goxQRCQlZWFkydPQiQSwdPTU/1Iy0lISADwdLumMl5eXgCA5ORkFBcXV7rlszJVrT4Dnq4827VrFwAgICAAVlZWCnOoiqv0sz948ADx8fFqxaOKWCzSyjj6VPYzmMLnIdIVvitE6uG7YnhyymwPBQAn/6b8u9GA2NoK7m07I/FsBABAkMmQcuEUGvYdWL1x+K4QqcT3hEg9dfldUSvb1KlTJ3z11VcoKCiocE8QBERGRlZrUkEQIBKJMGTIkGo9V1bptkxHR0el/ezt7eVzZmdnK13tpq5vv/0WqampAKBQnbTsVtHSVW2q4srOztY4HgCoV6/qhKAxcna2Vd2JiPiuEKmJ74phKEi8q9D2CQoyue9halvTPs/LE2wAkHblNNqPeK3G4/FdIVKN7wmReurau6LWFlEfHx+88847EARB4Vep8ter+gUAVlZW8Pf3x5QpU/DWW2/VOPDCwkIAULqNs3S+UkVFRTWer9Tq1auxceNGAECHDh0UkoRlxy87b2VK4y79HERERESmLu32TYW2S5PmeorEdDTs0Uehff/UUQgymZ6iISIiqrvU2y8JYPz48Rg/frzCtWeeeQYikQhLly6VH9xfWyQSSa3OBzxNrs2bNw8A4O7ujh9//BFi8X85yrK/r21pabmqOxk4sVgkz3BnZORBJhNUPEFUN/FdIVIP3xXDIggC0m7HyttiM3PI7N1M4nsYvbKpD3tff+Q8fLo6MD/tMW6djUS95kFqD8F3hUg1vidE6jHFd0Xd1fZqJ9iqUnYlW22ytrYGoHpVWtltrapWu1VFEAQsWLAAv/32GwDA1dUVf/zxB9zd3RX6lVYfBVSvTCu9r2qlm7pM4Yu2LJlMMLnPRKQLfFeI1MN3Rf/ykhNQnJ8nb9v7NgTEZvx70QLP4J7yBBsAJJw5DuemVRfcUobvCpFqfE+I1FPX3hWNllzduHEDN27cUGv1Wml1TW0pPcMsJydHab/SM84kEonK89oqU1BQgHfffVeeXPPx8cH69evRuHHjKmOqTlzOzs7VjomIiIjI2GTdYwVRXfEK7qHQToo8rqdIiIiI6i6t7GnMzc3F0qVLERISgnPnzlW4n56ejgEDBqBXr15Yvny5Vs5C8/f3BwAkJiYq7ZeUlATg6ZbO6m7hTE9Px+uvv44DBw4AeFoxdNOmTfDz86u0v6enp3xFmrK4BEFAcnKy/BkiIiIiU5d1lwk2XXFrHQyJ5X+7ItKir6AwO1N/AREREdVBGifY4uLiMGjQICxbtgz379/HnTt3KvR58OABBEFASkoKFi9ejGHDhiElJUWjeZs1awYAePjwIXJzqz67Izo6GgDQokWLao2fkpKCkSNH4sqVKwCA3r17Y926dahfv36Vz4jFYvnKttJ5KxMbGwupVAoAaNmyZbXiIiIiIjJGFVaw+TPBpi0SS0u4t+0sbwsyGZLPn9JjRERERHWPRgm23NxcTJo0CYmJiRAEAXZ2dvKz0cpydXXFhAkT4O3tDUEQcOvWLbz99tsoLi6u8dw9e/YEAJSUlCAiIqLSPklJSYiJiQEAdO/eXe2xMzIyMG7cONy/fx8AMGLECCxbtkzhjDVVcZ09exZPnjyptM/Ro0cBABYWFujUqZPacREREREZK65g0y3PcttEE7lNlIiIqFZplGDbsGEDEhMTIRKJMGTIEJw6dQqDBw+u0M/b2xsff/wxDhw4gHHjxgF4usJr27ZtNZ7b19cX7du3BwD89NNPFc48EwQB8+fPh0wmg7Ozc6VxVeXTTz+Vr8QbO3Ys5syZo3bV0kGDBkEikSArKwtLly6tcD8xMRGrV68GAAwbNgwODg5qx0VERERkjASZDFn3b8vbYnNz2HlXfuQG1YxX514K7aRzJyDIZPoJhoiIqA7SKMF2+PBhAEDr1q0xb948lVU6JRIJpk+fjqCgIAiCgN27d2syPWbOnAmxWIx79+4hNDQUp06dQnp6Oq5fv46wsDDs378fABAWFlZh9VlISAhCQkIwbdo0hevHjh3DkSNHAABt27bFO++8g7y8PKW/ylZS9ff3R2hoKABg1apVmD17NuLi4pCeno4DBw5g1KhRyMzMhJOTE958802NPj8RERGRMchLSUBJQb68be/bCGIzjYvZUxl2Xg1g7+svbxdmpCHjVtVHlhAREZF2afSdzZ07dyASiTBw4EC1nxGJROjfvz+uXbuG2NhYTaZHUFAQvv76a3z22WeIjY3FhAkTKvQZP348Ro0aVeH63btPS5m7uroqXF+zZo3895cvX0aHDh1UxnHkyBH4+PjI2x9//DEePnyIiIgIbNq0CZs2bVLob2Njg+XLl8PLy0vl2ERERETGLuvebYU2t4fqhmdwT+Q8vCtvJ0Yeh0vzQD1GREREVHdotIKt9KB+Z2fnaj3n7u4OAMjPz1fRU7WhQ4di27ZtGDx4MDw8PGBubg5HR0d069YNy5Ytw4wZM6o13tWrVzWOydLSEsuXL8f8+fPRqVMnODg4wNzcHN7e3hgxYgR27dqFtm3bajwPERERkTGocP4aCxzohFe5c9iSeA4bERFRrdFoBZunpyfu37+PW7duqe5cRmnxgOom5qrSvHlzfPfdd9V65ubNm5Vev3z5sjZCkp9LN2TIEK2MR0RERGSsKlQQ5Qo2nXBrHQyJpRVKCgsAAGnRV1CYnQlLByf9BkZERFQHaLSCrfQstc2bNyM3N1etZwoKCrB582aIRCK0bt1ak+mJiIiIyAhkl0+wcQWbTkgsLeHetrO8LchkSD5/So8RERER1R0aJdhGjBgBAEhLS8Obb76JR48eKe2fkZGBKVOmIDExEQC4uouIiIjIxD2tIBonb4stLGDn1UCPEZk2z3LbRBO5TZSIiKhWaLRFtEOHDnjxxRexb98+XL58GS+88AL69OmDdu3awdvbG5aWligsLERSUhKuXLmCw4cPIy8vDyKRCD179kTv3r219TmIiIiIyADlJccrVBB1aNAYYolEjxGZNq/OvXBx8Rx5O+ncCQgyGURijX6uTkRERCpoXB993rx5yMjIwNmzZ5Gfn4+9e/di7969lfYVBAEA0LFjR/z444+aTk1EREREBq5CgQOev6ZTdl4NYO/rL68mWpiRhoxb0awmSkREpGMa/yjLysoKq1evxjfffINmzZpBEIQqfzVo0ACfffYZ1q5dCxsbG23ET0REREQGrGKBgyZ6iqTu8AzuqdDmNlEiIiLd03gFW6mhQ4di6NChSE5OxrVr1/D48WNkZWXBysoK9erVQ0BAABo1aqSt6YiIiIjICFRYwcYCBzrnFdwDsVtWy9tJkccROHaK/gIiIiKqA7SWYCvl4eEBDw8PbQ9LREREREao4go2Jth0za11MCSWVigpLAAApEVfQWF2JiwdnPQbGBERkQnjaadEREREpBOykhJkl6kgKrGwhK2nrx4jqhsklpZwb9tZ3hZkMiSfP6XHiIiIiEyfVlewZWdnIz8/HzKZTF7QoJQgCCguLkZhYSFycnJw8+ZN7Nu3D+Hh4doMgYiIiIgMRF7SQ5QUFcrbDn6sIFpbPIN7IPFshLydGHkcfn0G6C8gIiIiE6dxgi03NxdLlizBnj17kJGRoY2YiIiIiMgElN8e6sACB7XGq3MvXFw8R95OOncCgkwGkZgbWIiIiHRBowRbSUkJJkyYgKioKACosGpNFQsLC02mJyIiIiIDVqHAAc9fqzV2Xg1g7+uPnId3AQCFGWnIuBUNl+aBeo6MiIjINGn0I6xdu3bh6tWr8nabNm0wYMAAeHt7QyQSISAgAIMGDUKvXr0UCh+IRCJ8+eWXOHWKZ0EQERERmaqse7cV2qwgWrs8g3sqtBMjj+spEiIiItOnUYLtwIEDTwcRi/H777/jzz//xA8//ICRI0dCEAS4urriu+++w/LlyxEREYFFixbB0dERALBnzx44ODho/gmIiIiIyCCxgqh+eQX3UGgnMcFGRESkMxol2GJiYiASiRASEoIuXbrIr3fo0AEAEBkZCZlMJr8eEhKChQsXAgAuXLiAI0eOaDI9ERERERkoWUkJsh+UqSBqaQU7VhCtVW6tgyGxtJK306KvoDA7U38BERERmTCNEmxZWVkAnm4NLat58+YQiUQoKCjArVuKP7ns2rUrunTpAkEQsHPnTk2mJyIiIiIDlZv4ALKiInnbwa8xD9ivZRJLS7i37SxvCzIZks/ziBYiIiJd0Mp3OfXr11do29jYwM3NDQAqJNgAoGfPp+dBxMTEaGN6IiIiIjIwLHBgGDw78xw2IiKi2qBRgs3JyQkAkJ6eXuFegwYNAFSeYHN1dQUAPH78WJPpiYiIiMhAVTh/jQUO9MKrXKGDpHMnIJQ5woWIiIi0Q6MEW/PmzQE8PWutPH9/fwiCgGvXrlW4V5pYKy4u1mR6IiIiIjJQXMFmGOy8GsDe11/eLsxIQ8ataD1GREREZJo0SrA9++yzEAQBR48exeHDhxXutWjRAgBw/vx5JCYmKtzbvXs3gIpbS4mIiIjINHAFm+HwDOY2USIiIl3TKME2bNgwODk5oaSkBGFhYRgzZgxu374NAOjbty/MzMxQXFyMcePGYceOHTh06BDefPNNXLt2DSKRCO3atdPKhyAiIiIiwyErLkbOwzvytsTKGrbu3nqMqG7zCu6h0E5igo2IiEjrNEqw2djY4IcffoCZmRkEQcCFCxeQm5sL4Ok5a6NHj4YgCHj48CFmzpyJd955BydPngQASCQSjBs3TuMPQERERESGJTfhPmRSqbzt6NeEFUT1yK11MCSWVvJ2WvQVFGZn6i8gIiIiE6TxdzrPPvssduzYgX79+sHCwkJe3AAAPv74YwwYMACCICj8Mjc3xxdffIGgoCBNpyciIiIiA8PtoYZFYmkJ97ad5W1BJkPy+VN6jIiIiMj0mGljkMaNG+Onn35CQUEBrKz+++mYRCLBDz/8gFGjRiEiIgIZGRnw8fFB//794ePjo42piYiIiMjAsMCB4fHs3BOJZyPk7cTI4/DrM0B/AREREZkYrSTYSpVNrpXVtm1btG3bVptTEREREZGB4go2w+MV3BMXy7STzp2AIJNx6y4REZGW8F9UIiIiItKqrHu3FdpcwaZ/dl4NYO/rL28XZqQh41a0HiMiIiIyLUywEREREZHWyIqlyHl4V942s7aFjbuXHiOiUp7BPRXaiawmSkREpDVMsBERERGR1uTE34esuEwF0YZNIBKJ9BgRlfIK7qHQTmKCjYiISGuYYCMiIiIirSl//poDt4caDLfWwZBY/ndmclr0FRRmZ+ovICIiIhPCBBsRERERaU3FAgdN9BQJlSextIR7287ytiCTIfn8KT1GREREZDqYYCMiIiIircm6Wy7BxhVsBsWzM89hIyIi0gUm2IiIiIhIayquYGOCzZB4lSt0kHTuBASZTE/REBERmQ4m2IiIiIhIK0qkRch5eE/eNre1g42rp/4CogrsvBrA3tdf3i7MSEP6ret6jIiIiMg0MMFGRERERFqRG38PQkmxvO3gxwqihsiz3Cq2xLPcJkpERKQpJtiIiIiISCsqnr/GAgeGyCu4h0KbCTYiIiLNmanTaenSpToLYOrUqTobm4iIiIhqT4Xz11jgwCC5tQ6GxNIKJYUFAIC06CsoyMyAlZOzniMjIiIyXmon2HS1vJ8JNiIiIiLTwAIHxkFiaQn3tp2ReDYCACDIZHhwOgLN+g/Rb2BERERGTO0tooIgVOuXmZkZHB0dYW1trXAdACQSCaysrGBlZaWzD0ZEREREtSvr7m2FNlewGS7PzornsN07eVRPkRAREZkGtVawHTlypMp7ly5dwqeffoqioiK0bt0ao0ePRqdOneDu7i7vk5ubi8uXL2P9+vWIiIiAra0tFixYgGeffVbzT0BEREREeldSVIichHvytrmtHaxdPfQXECnlFdwTF8u07586CkEm01s8RERExk6tBJu3t3el15OTk/HVV19BKpViwoQJ+PjjjyvtZ2dnh+7du6N79+5YvXo15s+fj7CwMGzZsgWNGzeuefREREREZBByHt6DUFIibzs2bMoKogbMzqsB7H39kfPwLgAgP+0xUmOuQeLB782JiIhqQqMqor/++iuys7PRpk2bKpNr5Y0bNw7dunVDfn4+fv31V02mJyIiIiIDwQIHxsczWHGb6PkVi5B67WIVvYmIiEgZjRJsx48fh0gkwqBBg6r1XEhICADg7NmzmkxPRERERAaifILNgQUODJ5XcA+Fdtyhv3Hw7Vexf9Jg5KUk6ikqIiIi46TWFtGqpKamAgAcHR2r9Zy1tTUAICMjQ5Pp5W7evImVK1ciMjIS6enpcHJyQmBgIEJDQ9GjRw/VA6hp9erVmDdvHqZOnYqwsLAq+wmCgI4dOyInJ0flmJcuXYKtra3WYiQiIiLSh6y7XMFmbNxaBwMiEfD/hchKZcRex8lZ/0PIbzv1FBkREZHx0WgFm4ODAwAgJiamWs+dP38eAFC/fn1NpgfwtADDsGHDsGvXLqSkpEAqlSI1NRXHjh3DpEmTMHfuXI3nAICrV69i0aJFavV98OCBWsk1IiIiIlNRYYsoV7AZvPRb1ysk10plxF5H6r+XajkiIiIi46XRCrb27dvj4MGD+PPPPzFy5MgqiyGUFRUVha1bt0IkEqFz586aTI/o6Gh88MEHkEqlCAoKwrRp09C0aVPEx8dj+fLlOHz4MMLDw+Hv749Ro0bVeJ6oqChMnDgR+fn5avW/fv06AMDc3BwnT56EhYVFlX25eo2IiIiMXUlhIXIT7svb5nYOsK7npseISB058fdU3ncNbFc7wRARERk5jVawvfbaawCA3NxcjB49GidPnqyyr0wmw44dOzBx4kQUFxdDIpHgjTfe0GR6LF68GAUFBfDz88OaNWvQqVMnODs7IygoCEuXLpWf9bZkyRLk5ubWaI4NGzZg1KhRyM7OVvuZ0gRbs2bN4OzsDFtb2yp/ERERERm77Id3IMhk8rajPyuIGgN7n4Ya3SciIqL/aLSCrUuXLhg/fjz++OMPJCcn480334SnpyfatGkDDw8PWFlZIT8/H/Hx8bh06RLS09Mh/P8y9M8//xxNm9Z860BcXBwiIiIAAG+99VaFZJVIJMKMGTNw8OBBZGZm4tChQxgyZIja40dFReHbb7/FhQsXAAABAQHyxJkq0dHRAIDAwEC15yMiIiIyVjx/zTi5BraDc7MAZMRW/B7XpXkgV68RERFVg0YJNgCYPn06LCws8Pvvv0MqlSIxMRFJSUkV+pUm1uzt7TFjxgwMGzZMo3lLV8uJRCL07t270j6enp5o0aIFrl+/jsOHD1crwfbee+8hISEBIpEIoaGhmDZtGlq3bq3Ws6UJtlatWqk9HxEREZGxqnD+GhNsRqP73F+wf+IgFGVnyq/ZuHnh2a9+1l9QRERERkijLaKl3n//fezduxejR4+Gn58fBEGo8Ktp06b43//+h/3792ucXAP+K6zg5eUFFxeXKvu1bNkSANRefVZWcHAw/vrrL8yePRtWVlZqPRMfH4/MzEwAgKurK+bPn4+QkBAEBgaiY8eOGDt2LHbt2iVPOBIREREZOxY4MF627l5oHzZL4Vr9gDawdffSU0RERETGSeMVbKUaNGiAWbOe/uOcmZmJtLQ0ZGdnw8HBAW5ubrC3t9fWVACAhIQEAICPj4/Sfl5eT785SE5ORnFxMczM1PvIq1atgr+/f7XjKl29BgBTpkyBVCqVt6VSKSIjIxEZGYndu3dj0aJFWjuHTSw2/nNOyn4GU/g8RLrCd4VIPXxXak92uQSbc6Nm/DM3Il4duym0Uy6dhQgCRGKt/CyeyCTw3xQi9dTld0VrCbaynJyc4OTkpIuh5TIyMgAAjo6OSvuVJvYEQUB2drbS1W5l1SS5BiiulHN0dMSUKVPQvXt32Nra4saNG/jll19w7tw5nDhxAh9//DF+/lk7y+/r1bPTyjiGwtmZBSCI1MF3hUg9fFd0p7ggHzkJD+RtK0dneDdtyCIHxqSeHZwbNUXGnaeJ0sKsdAhpD1H/mQA9B0ZkmPhvCpF66tq7ovUfSz1+/BjHjx/Htm3bEB4eLr+elJQk3zqpDYWFhQAAS0tLpf3Kbu0sKirS2vxVycvLg729PTw8PLBt2zaEhobC19cXLi4u6Nq1K1avXo1+/foBAI4cOYJjx47pPCYiIiIiXcm4GweUOfrCpUlzJteMkG/n7grth2dP6ikSIiIi46S1FWz79u3DypUrFbZIAsCYMWMAAFu3bsXy5csxZMgQfPjhhxqvcJNIJBo9ryuzZs3CrFmzUFRUBAsLiwr3JRIJZs+ejYiICEilUmzdurXKIg3VkZaWq/EY+iYWi+QZ7oyMPMhkPKeOqDJ8V4jUw3eldty/clWhbevTyCS+L6lLxGIRfDt3R9SG3+XX7pw4Br+Bo/UYFZFh4b8pROoxxXdF3R2DGifYiouLMX36dPz9998AoHB4f9mfXsbHx6O4uBhbtmzBqVOnsHbtWvj6+tZ4XmtrawCqV6UVFBTIf69qtZs2VZZcK+Xm5oagoCBcunQJV69erbJfdZjCF21ZMplgcp+JSBf4rhCph++K7mTeiVVoOzRswj9rI+TdsStEYjEEmQwA8OjqeRQXFUFsZq7nyIgMD/9NIVJPXXtXNN4i+tlnn2Hv3r0QBAEODg4YNmwYhg4dWqFfy5YtYWdnB0EQkJSUhMmTJ2u0ZbP0bLWcnByl/bKzswE8XTmm6ry22lRafKH0LDkiIiIiY1ShgmhDVhA1RlaOTnALaCVvF+fnIS0mSo8RERERGReNEmznz5/H9u3bIRKJ0KdPHxw6dAhff/01nnvuuQp9x44di6NHj6Jr164AgDt37mD79u01nru0CEFiYqLSfklJSQAAd3d3iGuxElLZlXyVKa0uWroSj4iIiMgYVUiw+TfTUySkKZ9gxXPYki/+o6dIiIiIjI9GGae//voLAODj44OFCxfCwcFBaX8HBwcsX75cvnpr3759NZ67WbOn37w9fPgQublVn/NReiZcixYtajyXupKTk/Hcc8+hTZs2WLp0qdK+t2/fBgA0bNhQ53ERERER6UJxQT5yEx/K25aOzrByrqfHiEgT5QsdpFw8o6dIiIiIjI9GCbaLFy9CJBJh6NChSs8cK8vCwgLDhw+HIAi4efNmjefu2bMnAKCkpAQRERGV9klKSkJMTAwAoHv37pX20SZXV1dkZWUhPz8fJ06cqLJfdHQ04uLiAAA9evTQeVxEREREupD9QLGCqEPDJnqMhjTl1a4TxGW+p0+LvoLi/Cd6jIiIiMh4aJRge/z4MYDqr8Ly8/MDoPr8NGV8fX3Rvn17AMBPP/1UYSxBEDB//nzIZDI4Oztj8ODBNZ5LXRKJBC+99BIAICoqCjt27KjQJy8vD7NmzQIA2NraYuTIkTqPi4iIiEgXsu7y/DVTYmZlDdfAdvK2rFiKR1Hn9RgRERGR8dAowVZ6fpiyLZqVKT3Y385OvVKnVZk5cybEYjHu3buH0NBQnDp1Cunp6bh+/TrCwsKwf/9+AEBYWBhsbGwUng0JCUFISAimTZumUQzlTZkyBU5OTgCAWbNmYfHixbh16xbS09Nx9OhRjBw5EtevXwcAfPLJJ3B1ddXq/ERERES1peL5a0ywGTuP9l0V2imXuE2UiIhIHRol2EpXop0+fbpazx08eBCA5uePBQUF4euvv4aZmRliY2MxYcIEdOnSBUOHDsWhQ4cAAOPHj8eoUaMqPHv37l3cvXtXXgRBW9zd3fHbb7/B1dUVUqkUP//8MwYMGIAuXbrgf//7H2JjY2Fubo5PPvkEr7zyilbnJiIiIqpNXMFmeiok2C5W7/t8IiKiukqjBFuvXr0gCAIOHjyIyMhItZ7566+/EBkZCZFIpJXzx4YOHYpt27Zh8ODB8PDwgLm5ORwdHdGtWzcsW7YMM2bM0HiO6mrVqhX27NmDsLAwBAQEwMbGBpaWlmjQoAFGjBiB7du34/XXX6/1uIiIiIi0KevebYU2V7AZP5fmQTC3/W+XScbtGBRmZegxIiIiIuNgpsnDY8aMwdq1a5GVlYXJkyfjo48+wssvv1xp34SEBPz+++/YuHEjgKfbQ0NDQzWZXq558+b47rvvqvVMTQosVOcZJycnTJ06FVOnTq32PERERESGrjj/CfKSylQQdXKBlRMriBo7sZkZ3Fp3QsLpo08vCAJSLp9Fg14v6jcwIiIiA6dRgs3e3h4LFizAW2+9hYKCAsydOxfz5s2Tn80GACNHjsSjR4/kWzEFQYBEIsE333wjP6uMiIiIiIxL1v04hTa3h5oO9/Zd/0uwAUi5eIYJNiIiIhU02iIKAN26dcPKlSvh5uYGQRBQXFyM3NxciEQiAMDVq1eRlJQEQRAgCAIcHR2xePFi9OvXT+PgiYiIiEg/WODAdFUsdMBz2IiIiFTRaAVbqc6dO+PAgQPYuXMnDhw4gKioKIXKohYWFggICECfPn3w6quvwsHBQRvTEhEREZGesMCB6XJo2BRWLq4oSE8FAOTE30NeSiJs3b30HBkREZHh0kqCDQCsrKwwYsQIjBgxAgCQl5eH3NxcWFtbw97eXr6ijYiIiIiMXzZXsJkskUgE93ZdcP/wLvm1lIun0aj/K3qMioiIyLBpvEW0Kra2tnB3d4eDg0OF5FphYSESExORmJioq+mJiIiISIcqbBHlCjaT4t6ui0I7mdtEiYiIlNJoBdvMmTMhEokwatQoBAQEqP3cyZMnMXXqVIjFYkRHR2sSAhERERHVMumTPOQlJ8jbVi71YenorMeISNsqnMN28QwEQeCuFCIioipotIJt+/bt2L59O0JDQ7Ft27ZqPy8IgibTExEREZEeZN+/rdDm6jXTY+vhDTvvBvJ2QXpqhb93IiIi+o9WtogWFhbi008/xezZsyGVSrUxJBEREREZKBY4qBvc21VcxUZERESV00qCzczMDIIgYPPmzRg1ahSSk5O1MSwRERERGaAK56+xwIFJ8uA5bERERGrTSoLt888/R8eOHSEIAq5du4YhQ4bgzBn+hIuIiIjIFHEFW93g1q6zQvvRlUjIiov1FA0REZFh00qCzcXFBatXr8aoUaMgCAIyMjIwceJErFixQhvDExEREZEB4Qq2usHKqR6cmrSQt6W5Oci4dV2PERERERkurSTYAEAikeCzzz7DN998AwsLC5SUlGDhwoWYOnUqcnNztTUNEREREemRNC8HTx4lydvW9dxgYe+ox4hIl9zLbxO9yG2iREREldFagq3U0KFDsW7dOri7u0MQBBw5cgTDhw9HXFycvI+ZmZm2pyUiIiKiWpB1T7GSpAO3h5o0j/bdFNopTLARERFVSusJNgBo1aoVtm3bhnbt2kEQBNy9exfDhw/H33//DQCwtrbWxbREREREpGPcHlq3uLbqAJHkvx+Op/57EcWFBXqMiIiIyDDpJMEGAPXq1cPatWvx6quvAgCePHmCDz/8EAsWLICVlZWupiUiIiIiHapY4KCJniKh2mBuY4v6LdvI27KiIjz+95L+AiIiIjJQOkuwAU+3gs6ZMwdz5syBubk5BEHAypUrMXv2bF1OS0REREQ6knVfcYuoo38zPUVCtcW9veI5bNwmSkREVJFOE2ylXn31Vaxduxaurq4QBAGxsbG1MS0RERERaVl2+RVsflzBZurc23VVaKdcOqOnSIiIiAxXrSTYAKBt27bYsmULWrduDUEQamtaIiIiItKSotwcPElNlret67vDwt5BjxFRbajXsjUkVv+doZx+8xqKcrL1GBEREZHh0SjBtnbtWqxZswbt2rVTq7+7uzvCw8Px6quvwsvLC56enppMT0RERES1KLt8gQOev1YnSMwt4Naqo7wtyGR4dDVSjxEREREZHjPVXarWqVOnaj9jYWGBOXPmaDItEREREekBK4jWXe7tuyLp3Al5O+XiGfg820+PERERERmWWtsiSkRERETGrUKCrSETbHWFezvFQgfJl1jogIiIqCy1VrDt2LFD/vuXX3650us1VXY8IiIiIjJcWeULHDDBVmc4N2kBC0dnFGVlAACy791GftojWNdz03NkREREhkGtBNuMGTMgEokgEokUEmKl12uq/HhEREREZLiy7t1WaDswwVZniMRiuLftjIcR++TXki+ehv/zL+svKCIiIgOi9hZRQRAqrf5Zer2mv4iIiIjI8BXlZCP/cYq8bePqAQs7ez1GRLXNo31XhXbKxTN6ioSIiMjwqLWCbd68edW6TkRERESmpfz5aw4scFDnlD+HLeXSaQiCoNGOFiIiIlOhVoJtyJAh1bpORERERKaF56+RnbcfbNy98CQlEQDw5FESchPuw96noX4DIyIiMgCsIkpEREREKrGCKIlEIri3U9wmmnyR1USJiIgAJtiIiIiISA0VEmzcIlonebQvt02UCTYiIiIAam4RXbp0qc4CmDp1qs7GJiIiIiLtqLhFtImeIiF9qnAO25VICDIZRGL+3J6IiOo2tRNsujq8lAk2IiIiIsNWmJ2JgvRUedvG3QvmNnZ6jIj0xbqeGxwaNkH2vdsAgKKsDGTcjoFLswA9R0ZERKRfav+oSRAErf8iIiIiIsPHAgdUlke5c9hSLp3RUyRERESGQ60VbGvXrtV1HERERERkoHj+GpXl3r4LYrf9998HKRdPo8XIiXqMiIiISP/USrB16tRJ13EQERERkYHiCjYqy61NZ4jEYggyGQDgUdR5lEiLIDG30HNkRERE+sPTSImIiIhIqQor2Jhgq9Ms7Ozh8kyQvF1SkI+06Cv6C4iIiMgA6DXBdu7cOX1OT0RERERqKJ9gc/BrrKdIyFC4lz+H7eJpPUVCRERkGNTaIqpKamoqDh48iHv37qGgoAAlJSWVFjGQSqUoKipCTk4OYmNjkZGRgejoaG2EQEREREQ6UJiZjsKMNHnb1sMH5ja2eoyIDIF7+66IXveLvJ186QyC3nhPfwERERHpmcYJtl27duHzzz9HQUFBtZ4TBAEikUjT6YmIiIhIh1jggCrjGtAOEgtLlBQVAgDSoq9C+iSPyVciIqqzNNoiev/+fXzyySfIz8+HIAhq/wKAgIAAvPHGG1r5EERERESkGyxwQJWRWFqiflB7eVsoKUZq1Hk9RkRERKRfGiXY1q9fj+LiYohEInTt2hWrVq3CgQMHMGjQIIhEIrzyyis4dOgQtm7dirlz56JFixbyZ0eMGIGPP/5Y4w9ARERERLrDAgdUFfd2XRTayTyHjYiI6jCNEmyRkZEAAG9vb/z666/o1q0b/Pz80Lt3bwiCgEuXLsHX1xcBAQF45ZVXsHnzZrz44osQBAHz5s1DSkqKVj4EEREREekGt4hSVTzalyt0cOmMniIhIiLSP40SbMnJyRCJRHj55Zdhbm4uvx4U9LRs9927d5GRkSG/bmZmhnnz5qF+/fooKCjAxo0bNZmeiIiIiHSs/BZRhwaN9BQJGRrnZoEwt7OXtzNvx6AgM03JE0RERKZLowRbXl4eAMDX11fhuo+PD6ytrQEAMTExCvesrKwwcOBACIKAs2fPajK93M2bN/Hxxx+jR48eCAwMxLPPPovJkyfjxIkTWhm/1OrVq9G8eXP89NNPKvsKgoAdO3Zg9OjRaN++PVq1aoXnn38eX3/9NZKSkrQaFxEREZEuFGSmoTDrvx+W2nr6wszaRo8RkSERSyRwaxOscC3lkna+vyciIjI2GiXY7OzsAEBeuKCs0qTbrVu3Ktxr2vTp1oJ79+5pMj0A4MiRIxg2bBh27dqFlJQUSKVSpKam4tixY5g0aRLmzp2r8RwAcPXqVSxatEitvjKZDB9++CGmT5+O8+fPIzc3F4WFhbh//z7Wrl2LgQMHai25SERERKQrFQscNNFTJGSoKmwT5TlsRERUR2mUYHNzcwMAPHz4sMK9hg0bAgBiY2MrTip+Om1ubq4m0yM6OhoffPABpFIpgoKCEB4ejrNnz2LLli3o27cvACA8PBzr16/XaJ6oqChMnDgR+fn5avVfuHAh9u7dCwAYP3489u/fj9OnT2PRokXw9PRETk4OwsLCkJycrFFcRERERLrE89dIFfd25c9hY4KNiIjqJo0SbB07doQgCNi+fTuKiooU7jVq1KjKbaDR0dEAAEtLS02mx+LFi1FQUAA/Pz+sWbMGnTp1grOzM4KCgrB06VKEhIQAAJYsWVLjZN6GDRswatQoZGdnq9U/JSUFf/zxBwBg0qRJmDFjBvz9/VGvXj28+OKLWL9+PZycnJCdnY1ly5bVKCYiIiKi2lBxBRsTbKTIwa8xrOu5ydu5iQ+RmxSvx4iIiIj0Q6ME28CBAwEASUlJGDt2LM6dOye/Fxz89DyGxMRE/Prrr/Lrly9fxubNmyESidCoUc0PyY2Li0NERAQA4K233oKtra3CfZFIhBkzZkAsFiMzMxOHDh2q1vhRUVEYNWoUvvzySxQVFSEgIECt59atWwepVAobGxtMnjy5wn1vb2+MGzcOALB79261V8URERER1aa8lETcO7hD4Vr0ul+Ql5Kon4DIIIlEIri366JwjavYiIioLtIowdamTRuEhIRAEARcvXoVr7/+Oo4fPw4A6Ny5szyBtmjRIvTr1w+DBg3C6NGj5Uml0hVmNXHy5EkAT/9R7927d6V9PD090aJFCwDA4cOHqzX+e++9hwsXLkAkEmHUqFHYsGGDWs+Vfv7g4GD5GXXl9enTBwCQn5+Pf/75p1pxEREREdWGk7P+h+L8JwrXsh/cwclZ/9NTRGSo3Cucw3ZGT5EQERHpj0YJNgD47rvvMGDAAHmhg9LiBiKRCPPmzYOVlRUEQUB8fDxu3bqFkpISAECLFi0wZsyYGs9bWp3Uy8sLLi4uVfZr2bIlAOD69evVniM4OBh//fUXZs+eDSsrK5X9pVIp4uLiAACBgYFV9mvatCnMzc1rHBcRERGRLqX+ewkZsZV/j5IRex2p/16q5YjIkLm3L7eC7fKZSougERERmTIzTQewsLDADz/8gIkTJ+LQoUPyBBsAtG7dGhs3bsR3332HM2ee/kNrbW2NgQMH4uOPP4aFhUWN501ISAAA+Pj4KO3n5eUFAEhOTkZxcTHMzNT7yKtWrYK/v3+1YiqdQ1VcIpEInp6eePDgAeLjtXNGhVgs0so4+lT2M5jC5yHSFb4rROrhu1JzOQ/ilN7PS7gH91btayka0jVN3xV7D2/Y+zRETvw9AEBB+mPk3L8Fp0bNtRUikd7x3xQi9dTld0XjBFupZ555Bs8880yl13///XcUFRUhKysLLi4ukEgkGs+XkZEBAHB0dFTaz97eHgAgCAKys7OVrnYrq7rJtbIxAYCDg4NacalbPEGVevUq345qrJydbVV3IiK+K0Rq4rtSPf/G31Z63yegpcl970FP1fRdaditJ65tuidv59y4iMYdmYQl08R/U4jUU9feFY23iKrLwsICrq6uWkmuAUBhYSEA1ZVIy27tLF/pVNvKjq9qS2lp3KWfg4iIiMgQ5KWmIHrHpirvuwW0hmfbjrUYERkDn87dFdoPz57UUyRERET6obUVbLVNW4k6bRKLay1fWUFaWq7e5tYWsVgkz3BnZORBJuPZHUSV4btCpB6+KzXzz9ezIc2r/PsKl2YB6PrlUpP4voP+o413xbZpG0AkAv7/7LWHkaeRmpIJsZrHsxAZOv6bQqQeU3xX1F21r5V/8W7cuIGDBw/i9u3byMnJkRcyUEUkEmHNmjU1mtPa2hqA6lVpBQUF8t+rWu2mKRsbG/nvVa1MK72vTvEEdZjCF21ZMplgcp+JSBf4rhCph++Keh5dPYd7B3coXGv91jRYudSHvU9DuAa2A2B633fQf2r6rpjbO8G5aUt5cYziJ7l4HH0V9f//a4bIlPDfFCL11LV3ReME27fffovVq1dX+zlBECAS1fzAu9IzzHJycpT2Kz3jTCKRqDyvTVOlMVUnLmdnZ53GRERERKQOWXExLiz6UuGaV5feaBn6pp4iImPj3q6rQvXZ5EtnmGAjIqI6Q6ME2/bt2/HHH3/I22KxGI6OjvLVZbrk7++Pc+fOITExUWm/pKQkAIC7u7vOt3B6enrCysoKBQUFSuMSBAHJycnyZ4iIiIj07daOdci6c1PeFltYoF3YLD1GRMbGo30X3PjzN3k75eJpBI6doseIiIiIao9GCbY///zz6SBmZpg5cyaGDBmisE1Sl5o1awYAePjwIXJzc2FnV/me2OjoaABAixYtdB6TWCxG48aNcf36dfm8lYmNjYVUKgUAtGzZUudxERERESmTn5aKa78vUrjWYuSbsPf2009AZJRcgzpAbGYOWfHT73MfX7+E4oJ8mFnp/ofvRERE+qbRkq7Y2FiIRCKMHDkSo0aNqrXkGgD07NkTAFBSUoKIiIhK+yQlJSEmJgYA0L1790r76Cqus2fP4smTJ5X2OXr0KICnlVU7depUK3ERERERVeXKr98pFDaw9fBGy1Fv6TEiMkZm1jaoF9BG3pZJpUi9dlF/AREREdUijRJspVsu27Wr/bMVfH190b59ewDATz/9VOHMM0EQMH/+fMhkMjg7O2Pw4MG1EtegQYMgkUiQlZWFpUuXVrifmJgoP7Nu2LBhcHBwqJW4iIiIiCqTeu0i7h3YrnCtXdgsrjqiGvFo11WhnXLptJ4iISIiql0aJdgaNWoEAMjIyNBKMNU1c+ZMiMVi3Lt3D6GhoTh16hTS09Nx/fp1hIWFYf/+/QCAsLCwCqvrQkJCEBISgmnTpmk1Jn9/f4SGhgIAVq1ahdmzZyMuLg7p6ek4cOAARo0ahczMTDg5OeHNN3loMBEREenP08IGXyhc8wzuCe9uffUTEBk99/blEmwXz+gpEiIiotql0RlsQ4YMwbVr17Bz506MGjVKWzGpLSgoCF9//TU+++wzxMbGYsKECRX6jB8/vtLY7t69CwBwdXXVelwff/wxHj58iIiICGzatAmbNm1SuG9jY4Ply5fDy8tL63MTERERqev2zg3IvB0jb4vNzdH+nc80qvROdVu9Fq1gZm2L4vw8AEB67L8oysmChb2jniMjIiLSLY1WsI0cORKdOnVCVFQUZs6ciYKCAm3FpbahQ4di27ZtGDx4MDw8PGBubg5HR0d069YNy5Ytw4wZM2o9JktLSyxfvhzz589Hp06d4ODgAHNzc3h7e2PEiBHYtWsX2rZtW+txEREREZXKT3+MqN8XKlxrMXIS7H0a6icgMgliM3O4te743wVBQMrlSP0FREREVEtEgiAImgzw5MkTfPjhh4iIiIC9vT06d+6MBg0awMrKSq3np06dqsn09P9SU3NUdzJwYrEI9eo9rQablpYLmUyjL00ik8V3hUg9fFeUOztvOu7u3ypv27h74aW1B3j2Wh2k7XflxqZVuPzzPHm76cuj0OH9LzUak0jf+G8KkXpM8V1xdbVXq59GW0QB4Ny5c4iJiYEgCMjOzsahQ4eq9TwTbERERES16/G/lxSSawDQbioLG5B2uHfoptBOvsRz2IiIyPRptEU0KioKYWFhSElJkZ/VIQiC2r+IiIiIqHbJSkpwfuHnCtc8OnWHT/d+eoqITI2TfzNYOrnI2zkP7uBJarIeIyIiItI9jVawrVixAlKpFADwzDPPYMiQIfDx8YG9vXrL54iIiIiodt3eVa6wgZk52r8zm4UNSGtEYjHc23XBg6N75ddSLp6Bf8gQPUZFRESkWxol2KKioiASidC+fXusXr0aZmYa7zglIiIiIh0pyExD1ErFwgbPjJgAB19/PUVEpqp8gi350mkm2IiIyKRptEU0KysLADBgwAAm14iIiIgM3NVfv4c0N1vetnHzRMCYt/UYEZkqj/ZdFdopl07ziBgiIjJpGiXY3N3dAQAWFhZaCYaIiIiIdOPx9cu48/cWhWvtpn4KM2sbPUVEpszOqwFsPXzk7fzUFOQ8vKvHiIiIiHRLowRbr169IAgCTpw4oa14iIiIiEjLZCUluLDoC4VrHh26wafHC/oJiOoE9/ZdFNopF0/rKRIiIiLd0yjB9sYbb8DBwQEHDx7Erl27tBUTEREREWlR3O4/kRF7Xd4Wm5mj/bufs7AB6ZR7O8VtosmXzugpEiIiIt3T6OA0Dw8PLFmyBGFhYZg+fTr+/vtv9O/fH/7+/nBycoJEIlE5hpeXlyYhEBEREZEShZnpiFr5o8K15q+Oh0ODRnqKiOoK93aKK9geXT4LWUkJxGr8NwIREZGx0SjB1r9//6eDmJlBEAQcP34cx48fV/t5kUiE6OhoTUIgIiIiIiWurvgBRTlZ8raNqwcCxkzRY0RUV1i71IejfzNk3Y0FABTlZCHjVjTqPROk58iIiIi0T6Mtonfu3MGdO3eQkZEBABAEodq/iIiIiEg30mKuIu7vzQrX2k75BOY2tnqKiOoa90qqiRIREZkijVawvfzyyzy7g4iIiMgAyUpKcGHhF0CZH2i6t+8K314v6i8oqnM82ndF7JbV8nbKxdNoGfqW/gIiIiLSEY0SbPPnz9dWHERERESkRXf2bkb6zWvytkhihvbvzOYPR6lWubXuCJFEAqGkBACQeu0iSooKIbGw1HNkRERE2qXRFtE1a9Zg48aNyM7O1lY8RERERKShwqwMXP3tB4VrzYePh2PDJnqKiOoqc1t71HumlbxdUliAx9cv6zEiIiIi3dAowfbXX39hzpw5CAsL01Y8RERERKShq78tQFF2prxtXd8dga+zsAHpR8Vz2M7oKRIiIiLd0SjBlpiYCAB48UWe5UFERERkCNJuXEPcnk0K154WNrDTU0RU17m366LQTrnIQgdERGR6NEqwWVhYKPwvEREREemPIJPh4qIvFAsbtOuCBr376y8oqvPqB7SFxNJK3k67EQVpXo4eIyIiItI+jRJszz//PARBwKZNmyCVSrUVExERERHVwJ2/NyMt5qq8LZKYof27LGxA+iWxsIRrUHt5WygpwaOr5/UYERERkfZplGCbOXMm2rdvj6ioKIwcORK7d+9GUlKStmIjIiIiIjUVZmfiyopyhQ1eeR2ODZvqKSKi/1Q8h43bRImIyLSYafLwvHnz0KBBA/z777+Ijo7GtGnTAACWlpawt7dXuXVUJBLh8OHDmoRARERERACifvsRRVkZ8rZ1PTcEjmMhKjIM7u0UE2zJF5hgIyIi06JRgm3z5s0KWw6E/z/vo6CgAAUFBSqf53YFIiIiIs2l3/wXt3dvVLjW5u2ZLGxABsO5aUuY2zlAmpsNAMi6G4v89Mewdqmv58iIiIi0Q6MEm5eXl7biICIiIqIaEGQyXFj0uUJhA7c2neDXZ4AeoyJSJJZI4N7u/9q77/imq/2P4++key9KW8rehQIKCqICegFFQRG8jgty7w8HeK+giFeFK6IXB3rv9ToA4TpR9LpRcVyQLagUFQUse1NoS+luoW3a5PdHaWjoCk3bJM3r+XjwaHK+I5/Qnp7TT84YqJRvV1jL0rf8oPbDrnNiVAAANByHEmxr1qxpqDgAAABQDwf+94kyd1Te2MBL/e57nJkCcDmxVRJs35NgAwA0Gw5tcgAAAADnKc7L0db//MOmrOvYPyq8Y1cnRQTUrMpGBz//4KRIAABoeCTYAAAA3NT2159XcaWNDfwjo9Vr4r1OjAioWUibDgqIjrE+L0xLUcHxI06MCACAhuPQFNFzffPNN1q1apW2bdumzMxMnT59Wv7+/oqJiVG3bt10xRVX6JprrpGPj09DviwAAIDHydqTrH3LbDc2uPAvM+QTFOKkiIDaGQwGxfS9VIdWfGotS/v5e3Vu1daJUQEA0DAaJMG2Z88eTZ8+Xfv377eWVewoWlBQoMLCQh04cED/+9//9Morr+hf//qXunfv3hAvDQAA4HEsZrN+fuFxWcxma1l0n4vVbtj1TowKqFvsOQm29C0/qPN1tzoxIgAAGobDU0STk5N16623av/+/bJYLLJYLAoJCVGPHj3Ut29fde/eXYGBgdZj+/bt06233qpdu3Y1RPwAAAAe5+CKT3Uy+Rfrc4OXly5iYwO4gZh+A22ep2/5wSZRDACAu3JoBFtxcbGmTJmiU6dOSZKuvvpqTZo0ST179qxy7rZt2/Tqq69q5cqVKioq0tSpU/Xll1/Kz8/PkRAAAAA8Skl+rn5d9KxNWZcxExTeqZuTIgLsFxgdq5C2HZV/5IAkqTgnSzkH9yiiE7NbAADuzaERbB988IFSU1NlMBh0//3368UXX6w2uSZJvXv31rx58zRt2jRJUkpKir7++mtHXh4AAMDjbHv9BRXnZFmf+0e2UK+J9zkxIuD8xPY9ZxTbT985KRIAABqOQwm2lStXSpL69OmjyZMn23XN3XffrQsuuEAWi0XLli1z5OUBAAA8SvbeHdr3+bs2ZRfc/bB8g9nYAO4jpt+lNs/Tt/zgpEgAAGg4DiXY9u/fL4PBoJEjR57XdaNGjZIkHTp0yJGXBwAA8BgWi0U/vfh3240Nel2k9lfd4LyggHqIufASqdJ6gSe2/ihzqcmJEQEA4DiHEmx5eXmSpOjo6PO6LioqSpKUmZnpyMsDAAB4jEMrPtPJ7T9bnxuMRvWb9hgbG8Dt+IaEKbJrovV56elCZe7c5sSIAABwnEMJtrCwMEnSsWPHzuu648ePS5JCQ0MdeXkAAACPUJKfp18WPWNT1uWG2xTROcFJEQGOqbKb6M/fOykSAAAahkMJth49eshisejzzz+XxWKx6xqz2azPPvtMBoNB3buzWxAAAEBdtr/5ooqzz47894uIUq/bpzkvIMBBMX1t12FL20KCDQDg3hxKsI0YMUKStHfvXj311FN2XfP0009r7969kqSrr77akZcHAABo9rL379LeT5fYlF1w98PyDWEmANxXdK9+Mvr4WJ9nJv+q0tOnnBgRAACOcSjBdv3116tTp06SpHfffVfjxo3TqlWrlJ+fb3Nefn6+Vq1apXHjxundd9+VwWBQu3btNGbMGEdeHgAAoFmzWCz6+fnHbTY2aJHYVx3Y2ABuzts/QC169rU+N5ealLH9JydGBACAY7wdudjHx0cvvPCCJk6cqJMnT+qXX37R1KlTJZWvrxYYGKhTp05ZN0OQyjuKYWFhevnll+Xt7dDLAwAANGuHVn5uk3QwGI26aNrjMhgd+owUcAkx/S7ViV+TrM/Tfv5Bcf0HOzEiAADqz+HeWZcuXfTBBx9o4MCBslgs1n+5ublKTU1Vbm6uTfmAAQO0dOlSdezYsSHiBwAAaJZKCvL168Jnbco6jx6niC49nBQR0LBi+5670cF3TooEAADHNcgQsvj4eL355pvavn271q9fr19//VVZWVkqLCxUQECAWrRooV69emno0KFKTEys+4YAAAAe7rfFL6ooK8P63C88Ur3vuN+JEQENK7J7b3kHBqn0VKEkKXvfThXnZssvLMLJkQEAcP4adI5mr1691KtXr4a8pV12796t1157TUlJScrKylJ4eLgSExM1btw4DR5c/2HmKSkpevXVV7Vx40alp6crODhY3bp100033aRRo0bVeJ3FYtHFF19cZS266mzZskVBQUH1jhEAADQ/Oft3a8/SczY2mPyQfEPCnBQR0PCM3t5q2ae/jv+wtrzAYlH6L5vU9oprnBsYAAD14PYLeKxevVo33nijli1bpvT0dJlMJmVkZGjt2rW666679OSTT9brvtu2bdP111+v999/XykpKTKZTMrOztamTZv0wAMPaOrUqSotLa322iNHjtiVXAMAADiXxWLRTy8+LktZmbUsqscF6jBirBOjAhpH7EWX2TxP//kHJ0UCAIBj3HqXgR07dmj69OkymUzq1auXHnroIXXp0kUpKSlatGiRVq1apSVLlqhDhw4aP3683fdNS0vTpEmTVFhYqPbt22vmzJnq3bu3MjMz9fbbb+vDDz/UN998o+eee04PP/xwleuTk5MllW8CsWHDBvn6+tb4WoxeAwAAlR1e9YUytv54tsBg0EX3s7EBmqeYvpfaPE/f8r2TIgEAwDF2JdhmzpzZKC9uMBj09NNP1/v6F198UUVFRWrXrp3eeusta7IqIiJC8+fP17Rp07R8+XK99NJLGj16tIKDg+267yuvvKLs7GyFhoZqyZIlatmypSQpMjJSTzzxhIKDg/XGG29oyZIlGj9+vFq3bm1zfUWCrWvXroqIYA0JAABgH1Nhvn5d+IxNWefr/6DIrqxhi+YprEMX+Ue2UFHWSUlSfsohFZ44rqCWrZwcGQAA58euBNunn34qg8HQoC9ssVgcSrDt379f69atkyRNnjy5ykgwg8GgGTNm6JtvvlFOTo5WrlypMWPG1HnfvLw8ffzxx5KkCRMmWJNrlU2ZMkUff/yx8vLy9Nlnn2nKlCk2x3fs2CFJbOgAAADOy/bF83Q684T1uW9YhHrfOd2JEQGNy2AwKObCgTq8+gtrWfrPP6jjNTc6MSoAAM6f3XMNLBZLg/1rCBs2bJBU3ihfeeWV1Z4TFxenhIQESdKqVavsum9SUpKKi4slSUOHDq32nKCgIA0cOLDG+1Yk2Hr37m3XawIAAOQe3KM9n7xlU3bB5AflFxrunICAJhLTb6DN8/SfmSYKAHA/do1gW716tUMvUlJSooULF2rZsmU2I+FGjhxZ73vu3LlTktSqVStFRkbWeF6PHj2UnJxsnbZp7329vb3VvXv3Gs9LSEjQihUrtGfPHpWUlFjXWUtJSVFOTo4kKTo6Ws8884zWrVunlJQUBQQEKCEhQb///e913XXXNfioQAAA4J4sFot+euHv52xs0Ecdr/m9E6MCmkbVddh+sM52AQDAXdiVYIuPj6/3C/z888969NFHdfDgQRkMBlksFrVq1UqPPfaYhgwZUu/7Hjt2TJKqrH92rlatytdvSEtLU2lpqby9a3/LFfeNjY2Vl5dXnfctKytTWlqa2rZtK+ns6DVJuueee2QymazPTSaTkpKSlJSUpC+++EIvvPBCg21yYDS6fwek8ntoDu8HaCzUFcA+7lRXDq36Uid+TTpbYDDo4vsfl5d3zX0RoKE4u66ExrdRcKu2Kjh+RJJ0OvOECo4eUFj7zk0eC1ATZ9cTwF14cl1ptF1ECwoK9K9//UsffvihdWqo0WjUbbfdpvvvv1+BgYEO3T87O1uSFBYWVut5ISEhkso/Gc7Ly6t1tFt97itJubm51seVR8qFhYXpnnvu0aBBgxQUFKRdu3Zp4cKF2rx5s7799ls9+OCDevnll2t9HXtFRdm3gYO7iIhgd1XAHtQVwD6uXFdKCguqbGyQeNMEdb3s0hquABqPs+pKu8sGK/mjd6zP83f+pI79LnBKLEBdXLlNAVyJp9WVRtnvffXq1Ro5cqQ++OADmc1mWSwWde3aVe+//74eeeQRh5NrkqzrpPn5+dV6nr+/v/VxSUlJo9y34hpJKiwsVEhIiGJjY7V06VKNGzdObdq0UWRkpC699FItXrxYw4cPl1T+/7R27do6YwIAAM3X5pefU+GJNOtz/7AIDZzWODu4A66qzSWDbJ4f3bTBSZEAAFA/DTqC7eTJk5ozZ45WrlwpqXzUmK+vr/7yl7/ozjvvrHN65vmobfqmM+87a9YszZo1y2ZdtnPvP3v2bK1bt04mk0mffPJJjZs0nI/MzAKH7+FsRqPBmuHOzi6U2dwwG2IAzQ11BbCPO9SVg998ri2LF9mU9Zn0V50q89WpZtC2wz24Ql0J6nKhzfOjm79TRnqOjA349wPgCFeoJ4A7aI51xd4Zgw3WYn300Uf65z//qfz8fOtOoRdffLHmzJmjDh06NNTLWAUEBEiqe1RaUVGR9XFdo9Iq37fyqLS67lt5NFuF6pJrFVq2bKlevXppy5Yt2rp1a50x2aM5/NBWZjZbmt17AhoDdQWwj6vVlcL049ow68/K3mO7CVNYp+7qcO1NLhUrPIuz6opvWKTCOycoZ1/5hmOmgnxl7v5NUQl9mjwWoC6u1qYArsrT6orDU0QPHz6sCRMmaPbs2dbkWkhIiObMmaMlS5Y0SnJNOrsGWn5+fq3n5eXlSSofOVbXumqSFBoaKql8DTl77itJERERdd73XBWbJFSs+QYAADxHdck1STKbSmQwNsoKHoDLi+k70OZ52s/fOykSAADOX717cGVlZfrPf/6j66+/Xj/99JN1I4OrrrpKX3/9tW6++eaGjLOKisTd8ePHaz0vNTVVkhQTEyOjHR3W9u3bW6+rGIlX2329vb0VHR1d5Xht10qy7i5aMWIOAAB4hozftlSbXJOk/CMHlPHbliaOCHANsf1sN/ZI3/KDkyIBAOD81SvBtn37do0dO1YvvPCCiouLZbFY1LJlS82fP18vvfRStQmnhta1a1dJ0tGjR2sdbbZjxw5JUkJCwnndt6SkRPv27avzvp07d7ZOB01LS9Pvfvc7XXDBBZo/f36tr1Nx74qEHgAA8AxZe36r9Xh+yqGmCQRwMdG9L5bB6+wKNie3/6yyOpZtAQDAVZxXgq2oqEhz587Vrbfeqj179shischgMOjWW2/V119/rWHDhjVWnFUMGTJEUvlIunXr1lV7TmpqqnbuLF/HYdCgQdWec67+/ftbR5WtWbOm2nNOnTqlTZs2VblvdHS0cnNzdfr0aX377bc1vsaOHTu0f/9+SdLgwYPtigsAALi/MlOJDnz1Ya3nhLRu3zTBAC7GJzBIUT3OrrlWVlKsjGRGdAIA3IPdCbaNGzdq5MiRevvtt1VWViaLxaKOHTvqnXfe0eOPP67gYPt2VWgobdq0Ub9+/SRJ8+bNq7IWm8Vi0TPPPCOz2ayIiAiNHj3arvsGBQVp+PDhkqQ33nij2imo8+bNU15ennx8fHTbbbdZy728vDRy5EhJ0rZt2/TZZ59VubawsFCzZs2yvtatt95qV1wAAMD9bZn3pHL27arxeGS3REUn9m3CiADXEnvOOmzprMMGAHATdu0i+uCDD+rLL7+0ritmMBg0evRo3X333fL19a1zHbTaVCz2Xx8zZ87UzTffrEOHDmncuHF6+OGH1aNHD6WmpmrhwoVauXKlJGnq1KkKDAy0uXbEiBGSpN69e+sf//iHzbHp06dr1apVysnJ0fjx4zVjxgxdfPHFys7O1ltvvaUPPvhAkjRhwgTFxsbaXHvPPfdoxYoVysnJ0axZs3T48GFde+21ioqK0q+//qrnn39ee/bskST97W9/a5LptAAAwPn2LXtP+z7/b43HI7r21OVPvNyEEQGuJ6bfpfrtrbNLraRv+V7SA84LCAAAOxksda3GL6l79+4yGAwN/+IGg3Uts/paunSpHn30UZWWllZ7fOLEiZoxY0aV8m7dukkqnxK6ZMmSKsc3bNigqVOn6vTp09Xed8SIEXr++eer3Thh27Zt+stf/qKMjIxqr/Xx8dGDDz6oP/3pTzW+r/OVkVH7bqruwGg0KCqqfCRkZmaBR23nC5wP6gpgH1eqKye2/qg190+QpexsfyWqxwXqM+mvKkw/rpDW7Rm5BqdxpbpSZirRJ6P6qayovA9uMBo1dtlP8g0JdVpMgORa9QRwZc2xrkRHh9h1nl0j2KS6d8V0lrFjx6pnz556/fXXlZSUpMzMTAUGBioxMVHjxo2r97pwgwYN0ldffaVXXnlFGzduVHp6unx9fdW9e3fdeOONGjt2bI1Jx969e+vLL7/UO++8ozVr1ujgwYMqKytTTEyMBg4cqAkTJqhLly6OvG0AAOAmCtOPa+Pse2ySawEtYjToyZcVENXSiZEBrsfLx1fRvS9S2uYNkiSL2awTW5PU+vLhTo4MAIDa2ZVgGzNmTGPH4ZBu3bpVmeZZl927d9d5Tnx8vP7+97/XK6bw8HBNmTJFU6ZMqdf1AADA/ZUWndaGWX9WcU6Wtczo60tyDahFbN9LrQk2SUr/+QcSbAAAl2dXgm3u3LmNHQcAAECzYrFYlPTsTGXvSbYp7//AU4pK6FPDVQBi+tludJC2hY0OAACuz+5dRAEAAGC/ne+9oiNrvrQp63bz7eowwrVnBgDOFtG5h3xDw63P8w7t0+nME84LCAAAO5BgAwAAaGDHN63T1lf+ZVMWe9FlumDyQ06KCHAfBqNRMRdeYlOWvuUHJ0UDAIB9SLABAAA0oLwjB/T9nGlSpQ2iguPb6tLHXpTR2+79pQCPFtPvUpvnaT+TYAMAuDYSbAAAAA2kJD9P3/5tskyFBdYy74AgDX76P/KrNOUNQO1iz0mwpW/5XpZKSWsAAFwNCTYAAIAGYC4r0w9PTlf+0YM25QMffU5h7bs4KSrAPQXHt1Ngyzjr81Ppx1Vw7LATIwIAoHYk2AAAABrAttf/reOb1tmU9brjfrW+bJhzAgLcmMFgUEzfc0exMU0UAOC6SLABAAA46NCqL7Tz3f/YlLUZMkI9J/zFSREB7i+m30Cb52k/feekSAAAqBsJNgAAAAdk7f5Nm5+dYVMW3qm7Bsx4VgaDwUlRAe4vpq9tgi391yRZzGYnRQMAQO1IsAEAANTT6ayT2vDI3SorKbaW+YZFaNBTC+UTGOTEyAD3F9giRqHtOlmfl+Rm68DypU6MCACAmpFgAwAAqIcyU4m+mz1FpzLSrGUGLy9d/vd5Co5r48TIgOYjsnsfm+ebn52h5XeNVmH6cSdFBABA9UiwAQAA1MOWl55QxvafbMr6Tp2lmAsvcVJEQPNzcvuPVcqy9yRrw6w/OyEaAABqRoINAADgPO39/L/at+w9m7JOI29Wlxtuc1JEQPOT8dsWFRw/Wu2x7D3JyvhtSxNHBABAzUiwAQAAnIcTvybp5xfn2JS1SOyrftMeY1MDoAHlpxyq9fiW+U+pMO1Y0wQDAEAdSLABAADYqTDtmDbOniJLWam1LCA6RpfPWSAvXz8nRgY0PyGt29d6PGvnVn05Ybi2vvqcTKcKmiYoAABqQIINAADADqWnT+nbR+5WcW62tczL10+DnlykgKhoJ0YGNE/RiX0V0bVnreeYS0q0452F+nL8cO3/6iOZy8qaKDoAAGyRYAMAAKiDxWJR0rMzlLNvp015/4eeVlT3Xk6KCmj+Bj25sEqSzScopMp5RVkZ2vyPmVox6Qal/7KpqcIDAMDK29kBAAAAuLod7y7SkbVf25R1v/UutR8+2kkRAZ4hKKaVRrz6uTJ+26L8lEMKad1e0Yl9lb7lB21Z8HSVpHfOvp1aM+02tb58uC7488N1TjMFAKChGCwWi8XZQcBxGRn5zg7BYUajQVFRwZKkzMwCmc38aALVoa4A9mmounLs+zX69m+TpUpdprj+gzX4mVdl9PJqkFgBZ3LXdsVcVqaDyz/Rttf+raKsk1WOG7191PXGP6rnhHvkGxLqhAjRnLhrPQGaWnOsK9HRVUdOV4cpogAAADXIPbRP3z9xv01yLaR1e106+3mSa4CTGb281GnkzRr17ir1uO3PMvr62hw3l5q064PX9eX4odr72bsyl5bWcCcAABxHgg0AAKAaJfm52vDI3So9VWgt8w4M0qCnFsk3JMyJkQGozCcwWH3uekAj3/5GbX83ssrx4txs/fT8Y1p+53VK3fytEyIEAHgCEmwAAADnMJeV6bs505SfcuhsocGgSx99XmHtOzstLgA1C45rrcsee1HDFnyoqIQ+VY7nHtyrdQ/ernUP3aHcQ/ucECEAoDkjwQYAAHCOra/8S2mbN9iU9b5zuuIv/Z2TIgJgr+jEvhr+8ke65JF/KSA6psrx1KT1+t/tI/XTC39XcW62EyIEADRHJNgAAAAqObTyc+16/1Wbsra/G6ke4+92UkQAzpfBaFSHq27QqHdWqdfE++TlH2Bz3FJWpr2fLtEX44Zq14dvqMxU4qRIAQDNBQk2AACAMzJ3bdfmf/zNpiy8c4IGPDRXBoPBSVEBqC9v/wAl/t9UjXpnpdpfPabKcVNBnn5Z8LT+93/XKuW7VbJY3H+3OwCAc5BgAwAAkHQ6M0MbZ/1ZZSXF1jK/sAgNfmqRvAMCnRgZAEcFRsdq4N/+qasWLVWLXv2qHM9POaQNf7tba6f/Udn7dzkhQgCAuyPBBgAAPF5ZSbE2zr5HpzLSrGUGL29d/sQCBcXGOzEyAA0pKqG3hs17X5c9/pKCYltXOZ6+5QetuPN6bf7nIzqdddIJEQIA3BUJNgAA4NEsFot+euFxnfxti015v/tmq2Wf/k6KCkBjMRgManvltRr59gr1mfygvAODbI5bzGbt//IDfTl+qHb89z8qKy6u4U4AAJxFgg0AAHi0vZ+9owNffWRT1vn6P6jL6HFOighAU/Dy81OPcZM16t3V6jTqFhmMtn8alZ4q1Nb//FNf/fFqHVn7NeuzAQBqRYINAAB4rPRfNmnLvCdtyqJ7XaS+9z7qpIgANLWAyBbq/+BTuvq1ZYrpd2mV44VpKfru8Xu1euoflLlruxMiBAC4AxJsAADAIxWkpmjjY1NlKSuzlgW2jNNlc+bLy8fXiZEBcIaITt115XNvadDTixTSun2V4xnbf9I3k8foh6cftFmvEQAAiQQbAADwQKWnT2nDI3erJDfbWubl66dBTy1UQGQLJ0YGwJkMBoNaXzZM1yz+WhdOeUQ+waFVzjm04lN9edtw/bZ4nkqLTjshSgCAKyLBBgAAPIrFYtGmuQ8pZ/8um/L+Dz+jyK6JTooKgCvx8vFV95sm6rr/rlaXMRNk8PKyOV5WdFrb33xRX902XAe/+UwWs1kZv23RgeVLlXHOhikAAM9gsLBaZ7OQkZHv7BAcZjQaFBUVLEnKzCyQ2cyPJlAd6ornyPhti/JTDimkdXtFJ/Z1djhup6a68tvbC7T99edtzk0YP1kXTHqwyWMEXAHtSt1yD+3Trwuf0fFN66o97uUfoLJKo9kiuvbUoCcXKiimVRNFiMZGPQHs0xzrSnR0iF3neTdyHAAA4DwVph/Xhll/VvaeZGsZf6w1jJSNK6sk11pdcoV63zHdSREBcAdh7TtryLOvKXXzt9qy4GnlHdpnc7zsnKmi2XuStWHWnzXi1c+bMkwAgBMxRRQAABdisVi0/qE7bJJr0tk/1lB/uQf36Icn/2pTFtK2owY++ryM50z/AoDqxPUfrGte/1IX3f93+YZF1Hpu9p5kff/EdKX/skllppImihAA4CxMEW0mmCIKeA7qSvNiOlWorF3bdDL5F2Xu+FUntv0oU0HNv9ND23VWVEJvhbbtqNB2nRTatpOCW7WR0dunCaN2D5XryvGDKVo+aYwKjh2xHvcJCtZVi5YqtG1HZ4UIuATalfopyc/T93OmKXXzt3We6x0YpNi+lypuwBDFDRjMaOQauPLSCNQTwD7Nsa4wRRTwUK7cMQE8ncViUf7Rgzq541dlJv+ikzt+Ve6B3bKYzXbfI+/wPuUdtp2aZPT2UXB8W4W27WSTeAtt20E+QfZ1CJozc2mpNj5+n01yTQaDLp39Ask1APXmGxKqnn+aYleCrfRUoVI2rlTKxpWSpND2ndVqwBDF9R+s6N4XycvXr7HDdWksjQCgOSDBBjQTdEwA11NSkK/MnVuVueNX6wi1kvzcBn8dc6lJeYf3K+/w/irHAqJjqkm8dVRAixgZDIYGj8UVfffvJ5X240absj6T/qpWl1zhnIAANBvRiX0V0bVnlWn9dck7tE95h/Zp1wevyzsgUDEXXqK4/oMVd8kQBce1aaRoXUtZSbFyD+1V9t6d2vrKP1Wck2VzPHtPspbfcZ06XHOjAiKj5R/ZQv6R0QqIaqmAyBbyDQ2XwciKRwBcB1NEmwmmiHouc6lJ+SmHtX7mXSo8frTKcf+oluoxbrJ8Q0LlGxwqn+AzX0NC5BscKu+AII/5I7u5oK64JovZrLwj+8sTacm/6uSOX5R7aJ9Uj2bW6OMrcyOv1+MdGFSebGt3JvnWtpPC2nVScHzbZjPd1Gg0aM+78/XjIttNDdoNvU4DH/03v/uAM2hXHFPth5xdeqjnH6coe+8OpSatV9bu7XbfL6RtR8X1H6xWAwarZZ8B8vJz/9FtJfl5yt63Q9n7dip77w7l7Nup3EP7ZCkrrfc9DV7e8o+MUkBkS/lHtihPwkWVJ+IColqWJ+POJOW8/QMcfg/UE7gSV5611Bzrir1TREmwNRMk2Jq/koJ85R3Zr7wjB8q/Hi5/XHDsiIOdE68zSbeQSgm4kLOJuODQKsm5yse9/APO+49UV24Q3IE71BVP+B6X5OfaTPXM3Lm11rXTauITFKyohD6K6nGhWvS8UFEJvVVadLraEamXPf6SLKWl1t8DuYf3K//IAeUe3qfSU4UN8r4MXt4Kjm+rsLadFNLubOItpE1H+Qbbdi6a+vtsLiuT2VSispJilZUUy3zma/m/krNlxUU6lZGmXR+8plMn0mzuEdahi65atLRB/tgCmgt3aFfcQW2/E4uyM5X64walJn2r1B83qCQ32657evn5q+UFA8qnkw4YrJDW7Rsh8oZjsVh0KiO1PIm2d6c1oVaYluLUuHyCguV/ZhRc+Wi4aAVERVcp8wuPrHHTG6PRoJIjO5Vz+IAM4bGK6tk8+zdwcv+muKhSH6ekUj+nvOxURpp2ffiGTqUft14f3rGbBs19RcGx8Y0eqz2aY5viUQm23bt367XXXlNSUpKysrIUHh6uxMREjRs3ToMHD673fVNSUvTqq69q48aNSk9PV3BwsLp166abbrpJo0aNqvVai8Wizz//XB9//LF27twpk8mk2NhYDRkyRLfffrvi4uLqHVd1SLA1DxaLRacz0qx/NFf+A/p05glnh1cto7ePfOxMzplNJu14d6Hyjx60Xs801vPnih08i8Uic6lJBSmH9P2c+5VzYLf1WESXHhr01CK3/h6by8qUe2hv+ci0M1M9845UnY5pj9D2ndWi54Vq0eMCteh5oULadqqxM29vB89iseh05onyxNvhfco7fOBMEm6fTmek1yvO6gREtVRou04KaBGjE78k6VRGqvVYSJsO6jXxXvkEhdaQAKu5s1jRmax8rOq1JTKXmhx+D2EduuraxV87fB+gOaEP1rTMZWXK3vObjietV2rSemXu3Gb3aOfg+LaK6z9ErS4ZopYXDHDqhwXm0lLlHz2grDMj0rLP/LM3eeiKDEaj/MKjKo2IK5+OavTx1cEVS1WYejZR2Bz6N7BVkHZMGx65Wzn7dlrLQtp0UK/b75NPYIhL929kMCi0bUcFx7VRUGy8gmJbl3+Na6Pg2Hj5hkU02cj95timeEyCbfXq1brvvvtkMlX/QzlhwgTNmjXrvO+7bds2/d///Z8KC6sfEXDVVVfp+eefl7d31WXszGaz/vrXv+qrr76q9tqQkBDNnz9fl1xyyXnHVRMSbO6lzFSigmOHraPQyr/uV96Rgyo93TCjUNyJl1+AYvsNPPMp4pnh/Gc6NP5nPl309vN3dpguoTD9uDbO+rOyqllrL6BFTJVGu6y4+sbctqzE9vk5nYGar7XtLNS6UL/BqMAWLSslXyslZUPCziZmQ0KrjKj0CQqpMQHliFpHGuRkKnPHVmsyLXPntnrVTZ/gUGsiLarnBYrq3ke+IaEN9RbsYjpVoLwjB8sTb0cOWJNw+SmHHRr96s6GLfiw2Y6sBOrDk/pgrqg4N1upP25UatJ6pf64QcXZmXZdZ/T1Vcs+/c9MJx2ikLYdG+0P6NLTp5Szf5d1RFr2vp3KPbBbZSXF9b6nd0CQIjonKLxzgo59v9pmRE6FkNbtlfh/U3U6M0NFWRk6nZWhoqyT5Y8zM1SSl+PAu2oABoMCWrQ8Z6ZHaKU+TUiVMmf2b1xFY8VosVhUVlIsU0GeSvLzVFKQZ31sKih/XlKQL1N+7tnHBWfPK3bj5HBdvAOCziTeziTf4uJtknG+IWEN9vujObYpHpFg27Fjh/7whz+oqKhIvXr10kMPPaQuXbooJSVFixYt0qpVqyRJs2fP1vjx4+2+b1pamm644QZlZ2erffv2mjlzpnr37q3MzEy9/fbb+vDDDyVJt99+ux5++OEq1z/33HN65ZVXJEkTJ07ULbfcotDQUG3evFnPPvusUlNTFRoaqi+++EKxsbEN8D9Bgs1VleTn2UznrHhckHpUlrKyBnkNn+AQhbbtqPyUw9V2MgJjWqnL6HFnGo58lZxpUEwF+WcaljyZ8vMa5pOTRuQTFHw26XbO0P6ASove+oaGN0pnpTGVlRTbNPAl+bnW78/ZRr/8+fFN6xpsKqA78QkKrj45Z5OUqz555xMYZLMIcnVr5YS27ah2w6637vBZcOzwecdoMBoV1qGros4k1Fr0uEAhbTq47ALM5lKTClJTzibeKhL9h/fLVFjg7PAa1YCZ/1DHEWOdHQbgMppjH8xdWcxmZe/dUT66bfO3ykz+xe6dpoNiW5/ZKGGwYi4cKJ/AoHrFUJSdqey9yTbJtPyjB+u1pmiFgKiWCu+coIguPRRx5mtwq7bWNrK+m3WVlRSrKCdTRZkndTrrhIoyT9ok4k5nnij/mnVC5pLGXdu0PrwDg870ZcKq9m+CQ+QTElZ9/yY4VD5BwXX2b1xtpog9MZ7bLzadSYSV94/zqv4dc04yzVzDwBvUzico+Oyot9jWCoprreBKz8/nA+Lm2KZ4RIJt8uTJWrdundq1a6dPP/1UQUFnGxGLxaJp06Zp+fLlCg8P1+rVqxUcHGzXfefMmaN3331XoaGh+uqrr9SyZUub488++6zeeOMN+fj4aPny5WrdurX1WHp6uoYOHSqTyaS77rpLf/3rX22uPXbsmMaOHaucnBzdfPPNeuKJJxz4HziLBFvTOfcTF4vZrFMZaWf+MK08Gu2AirIyGux1A1vGndkFsPOZBcnLH/tHtpDBYHCoUa34tOdsw5Vfzac95Ym46j7tKSnIa7CEoaMMXl7yPzO03zYJV3nR2/JjNXU8z/dTNXOpqVICs+L/Kre8M1BNkuzcjoAjn/7CDgaDfIJCrJ3TgmOHVXr6lMO39Q2LqDQ67UJFde8ln0D72hlXZrFYVJSVUXWE7eH9OpWRVvcNGpjR20dGX195+fqd/efnLy9fvyrlxjNfS/JzdXTd/2q8JyPYAFvu0gfzRCX5uUr7caOOb96gtM3f2r1kiNHbR9G9L1LcgCFqNWCwQtt30cnkX6r0YQuOH7Em0So2H3BoWRKDQSFtOliTaOUj1HooILKFXZc35sgmU2GBijJPnE2+ZWVYR8IVVSorzslyKJnYZOzs3/iFRartldc4IcCqjqz9n4pzs6qUG3195RcSrpKCPJUVFzkhsqZn8PI+06ep2o8p/+dbpawkP1dH1y93Srw+waEKio0vT7rFtT47Ci62jYLi4m36wK64nI2jmn2Cbf/+/br22mslSU8//bRuvPHGKuekpqbqd7/7ncxms5555hmNGTOmzvvm5eXp8ssvV3Fxse655x7de++9Vc4pLCzUFVdcoby8PE2dOlVTpkyxHqsYvRYYGKgNGzZUm9RbuHChXnjhBQUEBOiHH35QQIDjayc0lwSbMytixRpS1c2hLysu0qm0Y9r62r9tRrZ4nZm22FANgdHbRyFt2p+TSOukkDYd7P4U0hnDwi0Wi0pPn7JNzp2TlMs9tFdH1lQ/bdpZvAMCz6yxUZ508/IPVPpPG206lgHRMWo96CrJYqkxSVZWdNqJ78K5Kjf8kho0qexKDF5eCu/YrTyZdiapFhzfzuN2oTSdKtCRdcu1+dkZNZ7TauCVCoptfU6H8ZwE2bmdyBo6l0Yf33qPSF1+12ibDxwqRHZL1NWvfFavewLNFQk292CxWJSzb6dSN3+r40nrdfK3LXZ/wGnw9pal9OyyAN7+gbLI4lAfxsvXT2Edu9kk08I6dqv3yDlXYS41qSgny5p0O7HtJ+18d5Gzw0JjM3pJ5prrU3n/Jr6a/orvOR/++Z3T5/GtUmb08ZWxmqWm7FFT/yaia6Ku+MfrKkg9qsK0YypMS1Fh6jEVpJ193pijOH1DwxUUGy//iChl70lWUaWp7q42krI+mn2CbfHixZo7d64MBoO+//57RUZGVnve2LFjlZycrGHDhmnBggV13nflypXWhNnSpUvVs2fPas+79957tWLFCiUkJOizzz6zll9//fXavXu3rrzySi1aVP0v4j179ui6666TJC1YsEDDhg2rM666uHuCrbp1pcI6dNVF0x6Tb2hE3WtIFdu5tpTNGlMlVcqb6tMqn+DQ8l352nZSaNuOCmvXSaHtOikotnW9f9m6g5oahLCO3TTgoafLP0nMPDOs32aIf/lXVxza70r8IlrINyS0xk+9bDsEvtUnOmr9JM22M2H08a2SYKotqTH85Y9lOlVQ7RTYmqYwVx791xCjzuzlFxFVPs3zzFTPyG695B0Q2GSv7+rcIXlV23qF7tzBAxoDCTb3VFKQr/Qt3yt103od37y+QTe1OZdvaLg1kRbeOUGRXXoopE3HZt1vrcye/k31a3ydneFg2+dxTv+mOTMYjWfX8Q0Jq37zNZtjtse9/AO0YtINbtG/qc+sJYvZrKLskypMTVGBNQGXUv417ZgK04816vTaiK49NeLVzxvt/o3N3gSb2/5G3LmzfGePVq1a1Zhck6QePXooOTlZyclVK0pt9/X29lb37t1rPC8hIUErVqzQnj17VFJSIl9fX5lMJu3fX76rXGJiYo3XdunSRT4+PjKZTNbkn6c795eEJOUe3KPV99m/dp4rCoxpVf20zogojxv5IkmDnlzo0DRWU0G+Ndl27nD+okprbRTnZrvN0P66dl89d82NH5+bpbzDVXevdJWGv6bv8eVPvCyjt7f8QsPlFxper3tXOxX33LU4alm/zp6Rpon/d686jBijoNjWHllH7VXb99lVBMW00jWvL2t2UxQAoIJvcIjaDL5abQZfLYvFotyDe5WatL58dNv2n+u9vm5QbOuzybQu5V8Do+M8ul0c9OTCaj+0aaj+zdk1xapfa8x2CZfc8+7fuIvq1tc9d/OrKsdDyo95BwQ5/DPqLv2bEa9+ft6zlgxGowKiWiogqqVaVHO+xWzW6cwT1tFuBZWTb6lHVZie6tDmWNl7kpXx25Zmv0SH2ybYjh07Jkk2659Vp1Wr8j/a09LSVFpaWu2un9XdNzY2Vl61TEupuG9ZWZnS0tLUtm1b62vUFZfBYFBcXJyOHDmilJSUGs87H0aj+zZ4Gdt/rvaTAncSEB2j6J59FXpmJFrYmWQaI15shcTF69rXlylj+89nG4Re/ey82iCvsDD5h4UpvEPnWs+0Du3PtE3GlX89eabshE5nZjg8vbPy4vsVu2GWN/ZnE2Q2i/BX7hCcs/i+PX733GJ9+8iflbX7N2tZZNeeGvzUQpf4PeDY97h2Rl9feUe2kOxcx+VcFYvmrr7vNuUe2lvleGS3RPW54z5Hw/QIjfl9bkhGo0FxF16suAsvVnZ2IaNygBpUbj9coS1BfRgU2bmbIjt3U8/xk2Q6VaC0n3/Qro/e1Ilfkmq8KjA6TjH9LlFkl56K6FK+o6dfSFgTxu0eQuLiNfLNL1R0aIdyDh+QMTJOLRroQ5vy/k2UAiKj6nV9WUmxTIX5WnVv9f2b4Pi26jflEUfDbBA/z3tKBcePVCmP6NJD17z2udM3hnKX/o0kxfTup5jeDRib0UvBMXEKjomT+lxU5bC5rEynT6arMO1Y+TTU1GMqSEtRYepRFaQd06kTqXVOWS88dqhhY3ZBbptgy84u30I3LKz2BiAkpHwon8ViUV5eXq2j3epzX0nKzc21uVaSQkNr32Wj4vq8vLxaz7NXxbB+d3Qip+kXza7M2z9AXr5+8varmBrnb33sfeZ5adEpHfvxhxrvMeqF1xV34cVNGLV7i7piiKQhjfsiMRGSOtV5WklhoU6dPKEj36/Xuieq7gpcYeC0vym2d98zn1CGyu9MMq2pdyyNiuqq2z5drdRfflTO4QMKb9fRJX/2muR7fN6CJUVp7Gvv68t7JypjxzbrkegevTXqpTcV4sa/S53BNb/P1YuIcO81gYCmQl1pJqKCFdtmjGLatdZH40fVeNrIF151yX6Ey4q42AX/v+zo37SqfVBKU+l48UU1xxht/y6Vjc2d+jdNqmWY1KNrtYfMpaU6sGa5vp52R42Xt+7Zw63zFvZw2wRbcXH5rnt+fn61nufv7299XGLH+k31uW/FNZXvX/l4dSruX3GtJwtv17HW4zG9+yqoRcszCS//WpJhAZXKz5zr5yfvM4tOelvL/eTlHyBvXz8ZfXzsHkr83u+H2zQGFVr27OOCDS3s5RsUJN+gDgpv10HJn7xb4/f44kmuNbKpYlQOzl9Iq9b6w8crXT5JCQCAo+IuvFjRPXrTh/UA7tC/cYcYUT9Gb291vmqUx/++cdsEW23TN511X6MTh7RmZhY47bUd5ds2QZFde9qsaVAhsluihi34qEFex3zmn0mSiiUVl0iyf9H8y+Ys0Ld/u9smzsiuPXXp3+e79f8/znKX77HRaLCOMGDaW/35tk1Qy7YJktz7dyhqRl0B7ENdad7cpX/j6tylnrhD/8YdYkT9XDZnQbXL2bj77xt7R965bYItICBAUt2j0oqKzi76WNeotMr3rWtkWeX7VoxWCww8u95WXddXHK9rpJu9XPUXvL0ur2XhUFd5bwHRcbq6hgUlXSVGOMYdv8dms8VlYwNcCXUFsA91pflxx/6Nq6OeANULiI7TNa99Xu0mU55QZ9w2wVaxhll+fn6t51Wscebl5VXnumrS2bXTCgpqz65WXjstIiLCJqbziaviWk/nTru9RSf2bfa7n3g6vscAAKC5oX8DoKlULGeTmVngEYm1Cs7dpsMBHTp0kCQdP3681vNSU1MlSTExMXZN4Wzfvr31Ooul5h+Eivt6e3srOjpakhQXF2cdkVZbXBaLRWlpadZrcFbchRcr4YZbXHa3FgAAAAAAgHO5bYKta9fy3SuOHj1a62izHTt2SJISEhLO674lJSXat29fnfft3LmzfH19JZWvwdapUyeb49XZs2ePTCaTJKlHjx52xQUAAAAAAADX5LYJtiFDyrfNLSsr07p166o9JzU1VTt37pQkDRo0yK779u/f37oO25o1a6o959SpU9q0aVO1962Ia9OmTTp16lS111fc19fXV/3797crLgAAAAAAALgmt02wtWnTRv36lU8jnDdvXpU1zywWi5555hmZzWZFRERo9OjRdt03KChIw4cPlyS98cYb1U71nDdvnvLy8uTj46PbbrvN5tj1118vLy8v5ebmav78+VWuPX78uBYvXixJuvHGG61rvgEAAAAAAMA9uW2CTZJmzpwpo9GoQ4cOady4cdq4caOysrKUnJysqVOnavny5ZKkqVOn2uzwKUkjRozQiBEj9NBDD1W57/Tp0xUYGKicnByNHz9eK1asUFZWlvbv36/Zs2frjTfekCRNmDBBsbGxNtd26NBB48aNkyS9/vrrmj17tvbv36+srCytWLFC48ePV05OjsLDwzVp0qTG+G8BAAAAAABAEzJYalvJ3w0sXbpUjz76qEpLS6s9PnHiRM2YMaNKebdu3SSVTwldsmRJleMbNmzQ1KlTdfr06WrvO2LECD3//PPVbpxQXFyse++9t8apq4GBgXrjjTd04YUX1vS2zltGRu27lroDo9GgqKhgSfK43UaA80FdAexDXQHsQ10B6kY9AezTHOtKdHSIXed5N3IcjW7s2LHq2bOnXn/9dSUlJSkzM1OBgYFKTEzUuHHjNGzYsHrdd9CgQfrqq6/0yiuvaOPGjUpPT5evr6+6d++uG2+8UWPHjpXBYKj2Wj8/Py1atEifffaZli5dql27dun06dNq2bKlLr/8ct11111q06aNI28bAAAAAAAALsLtR7ChHCPYAM9BXQHsQ10B7ENdAepGPQHs0xzrir0j2Nx6DTYAAAAAAADA2UiwAQAAAAAAAA4gwQYAAAAAAAA4gAQbAAAAAAAA4AASbAAAAAAAAIADSLABAAAAAAAADiDBBgAAAAAAADiABBsAAAAAAADgABJsAAAAAAAAgANIsAEAAAAAAAAOIMEGAAAAAAAAOIAEGwAAAAAAAOAAEmwAAAAAAACAAwwWi8Xi7CAAAAAAAAAAd8UINgAAAAAAAMABJNgAAAAAAAAAB5BgAwAAAAAAABxAgg0AAAAAAABwAAk2AAAAAAAAwAEk2AAAAAAAAAAHkGADAAAAAAAAHECCDQAAAAAAAHAACTYAAAAAAADAASTYAAAAAAAAAAeQYAMAAAAAAAAcQIINAAAAAAAAcAAJNgAAAAAAAMABJNgAAAAAAAAAB5BgAwAAAAAAABzg7ewAgN27d+u1115TUlKSsrKyFB4ersTERI0bN06DBw92dniAS3jyySe1ZMmSOs979NFHddtttzVBRIDrqKgfc+fO1dixY2s912Qy6b333tOyZcu0f/9+WSwWxcfHa9iwYZo4caLCw8ObJmjACeytKzk5ORowYECd9wsPD1dSUlJDhgg4zfr16/XJJ5/o119/VVZWlnx9fdWuXTsNGTJEf/zjHxUZGVntdbQr8DT1qSue0q6QYINTrV69Wvfdd59MJpO1LCMjQ2vXrtXatWs1YcIEzZo1y4kRAq4hOTnZ2SEALmnVqlV699137Tq3uLhYd955pzZv3mxTvm/fPu3bt09Lly7V66+/rq5duzZGqIBTnU9d2bFjRyNHA7iO0tJSzZgxQ1988YVNuclk0o4dO7Rjxw59+OGHWrBggS688EKbc2hX4EkcqSue0q6QYIPT7NixQ9OnT5fJZFKvXr300EMPqUuXLkpJSdGiRYu0atUqLVmyRB06dND48eOdHS7gNGazWbt27ZIkPfbYYxo9enSN5/r6+jZVWIDTrVmzRtOmTZPZbLbr/JkzZ2rz5s3y8fHRlClTNGrUKPn6+mr9+vX65z//qRMnTujuu+/Wl19+qcDAwEaOHmg651tXKj7UiY2N1ddff13jeQaDoUHiA5zpueeesyYMhg4dqjvvvFMdOnRQRkaG1q9fr5dfflmZmZm6++67tWzZMsXExFivpV2BJ3GkrnhKu8IabHCaF198UUVFRWrXrp3eeust9e/fXxEREerVq5fmz5+vESNGSJJeeuklFRQUODlawHkOHjyoU6dOSZL69eunoKCgGv/5+Pg4OVqg8ZnNZr300ku65557bEZA12b79u366quvJEmPPPKI7r77brVu3VotW7bUTTfdpMWLF8vHx0fHjh3T22+/3ZjhA02mPnVFOvuHUO/evWttc0gYwN2lp6dbf+dfd911evnll9W3b19FRESoa9euuuuuu/T222/L29tbOTk5+s9//mO9lnYFnsSRuiJ5TrtCgg1OsX//fq1bt06SNHnyZAUFBdkcNxgMmjFjhoxGo3JycrRy5UonRAm4hooGKTAwUJ07d3ZyNIBzbdiwQaNHj9aCBQtkNpvVs2dPu6578803JUmtW7fWzTffXOV4jx49dMMNN0iSPvroowaLF3CW+tYV6exUnl69ejVWeIBLWLVqlUpLSyVJ999/f7Xn9OrVS8OGDZMk698vEu0KPIsjdUXynHaFBBucYsOGDZLKE2lXXnlltefExcUpISFBUnmFBjxVRYPUo0cPeXl5OTkawLnuvPNO7dmzRz4+Ppo6dapeeOGFOq+xWCzWdufKK6+ssR4NHTpUkpSSkmKdlg24q/rUFUkqKCjQkSNHJDX/P4SAEydOyN/fXy1atFB8fHyN57Vr1856vkS7As9T37oieVa7whpscIqdO3dKklq1alXjjjxSeUIhOTmZBd7h0Sp+/hMSEvThhx9q2bJl2rlzp0wmk+Lj4zV06FDdcccdioiIcHKkQOMzGAwaPny4pk2bpk6dOiklJaXOa1JSUpSXlydJtY7i6dGjh/Xxb7/9pu7duzseMOAk9akrUnmbY7FYZDAYFBAQoNmzZ2vjxo06ceKEgoOD1bt3b40fP15Dhgxp5HcANL77779f999/f53L0Rw+fFiSFBYWJol2BZ6nvnVF8qx2hQQbnOLYsWOSyodU16ZVq1aSpLS0NJWWlsrbmx9ZeBaLxWIdwfb+++9XWUPnwIEDOnDggD755BMtXLhQF1xwgROiBJrO//73P3Xo0OG8rqloc6Ta253o6Gj5+PjIZDLZnYwAXFV96op0dtS0wWDQ+PHjrVOCJCk7O1vr16/X+vXrNXbsWD3xxBP0zdAsBAcH13gsPT1da9eulVS+Fq5EuwLPdb51RfKsdoUponCK7OxsSbaZ7eqEhIRIKk8yVHxKBHiSw4cPWz8pKi0t1S233KJPPvlEmzZt0hdffKFJkybJ29tbWVlZmjRpko4ePerkiIHGVZ+EQUWbI0mhoaE1nmc0Gq1rgtLmwN3Vp65I5aNspPINEuLj4/WPf/xD69at03fffacFCxZYR+AsXbpUzz77bIPFC7gii8Wi2bNnq7i4WJI0btw4SbQrwLlqqiuSZ7UrJNjgFBUVz8/Pr9bz/P39rY9LSkoaNSbAFaWnpys2NlZGo1HPPPOM5syZo8TEROuOPQ888ICef/55SVJubq7++c9/OjliwPVUtDmSbbtSnYp2qfI1gCcpLi5WYGCgEhIStHTpUo0ePVpxcXFq0aKFhg0bpg8++MA6WnrJkiXavXu3cwMGGtHcuXOti7WPGjVKl1xyiSTaFeBcNdUVybPaFRJscAoWagfsM2DAAK1fv15bt2617kR1rquuusq6WcjKlSuVm5vbhBECro82B7Df/Pnz9csvv+ijjz6qdiqQv7+/Hn30UUnlIxaWLl3a1CECjc5isWju3Ll66623JEldu3bVnDlzrMdpV4ByddUVybPaFRJscIqAgABJdY9KKyoqsj6ua7Qb0Jz5+vrWerxilyqz2Wwdhg2gXEWbI9U9gqDieF0jEoDmzsfHp8ZjiYmJiomJkSRt3bq1qUICmkRJSYkeeughLV68WJLUqVMnvfHGG9apnhLtCiDZV1cq84R2hQQbnKJibbX8/Pxaz6tYq8DLy6vO9doATxYXF2d9nJWV5cRIANdTeX2c2tods9mswsJCSWJXXqAOFRtRVV6LCnB3OTk5uv3227Vs2TJJ5TuEvvPOO4qOjrY5j3YFns7eunI+mkO7QoINTlGx8O7x48drPS81NVWSFBMTI6ORH1d4LovFUuvxyruLVv5UFYDUvn176+Pa2p2MjAxrXaqctAY8UV3tTsUsBNocNBdHjhzRLbfcoh9//FGSNGjQIC1ZskSRkZFVzqVdgSc7n7pSmSe0K2Qs4BRdu3aVJB09etS6Q2J1Krb0TUhIaJK4AFfzwAMPaMCAARo2bFit5+3bt8/6uL47xwHNVcuWLRUeHi7pbLtSneTkZOvjHj16NHZYgMvZunWrrrjiCvXu3VuffvppjeeVlZXp0KFDkmwTDYC72rt3r2655Rbrz/XNN9+sRYsW1TjVjXYFnup864qntSsk2OAUQ4YMkVRekSp2GzlXamqqdu7cKak8Kw54otDQUOXk5CglJcUmiVaZxWLRV199JUmKj49Xx44dmzJEwC1UtDvr1q2r8RPUNWvWSJKio6OtW8YDniQ+Pl5paWkqLi7W+vXrazxvzZo11mlvgwcPbqrwgEZx9OhRTZw40brExn333acnnnhC3t7etV5HuwJPU5+64mntCgk2OEWbNm3Ur18/SdK8efOqrF1gsVj0zDPPyGw2KyIiQqNHj3ZGmIDTXXfdddbHTz31VLUduFdffdWajL7jjjtkMBiaLD7AXYwZM0aSdODAAf33v/+tcnzHjh367LPPJEl/+tOfqEfwSC1atNBll10mSVqxYoU2b95c5ZyMjAzNnTtXkhQbG6uRI0c2aYxAQzKZTJo2bZoyMjIkSTNnztRf/vIXu66lXYEnqW9d8bR2hQQbnGbmzJkyGo06dOiQxo0bp40bNyorK0vJycmaOnWqli9fLkmaOnWqAgMDnRwt4Bx9+/bVqFGjJEnff/+9/vSnP2nz5s3KysrSrl279Oijj+q5556TJPXv319/+MMfnBku4LIGDhyo3/3ud5LKk9XPP/+8jh49qoyMDH388ceaOHGiTCaTWrduTT2CR3vwwQfl5+cni8WiyZMn680339ShQ4eUkZGhL774QrfccouOHTsmb29vPfXUU+zyDrf2wQcfWHdfv+aaa3TTTTepsLCw1n8VaFfgSRypK57Urhgsda00BzSipUuX6tFHH1VpaWm1xydOnKgZM2Y0cVSAaykqKtK0adO0du3aGs+59NJLNW/ePAUHBzdhZIDzpaSkaOjQoZKkuXPnauzYsTWem5ubqzvuuEPbt2+v9niLFi303//+V+3atWuUWAFnOp+6sn79ek2fPr3GdXIDAwP19NNP65prrmmUWIGmMnz4cB05cuS8rtm9e7f1Me0KPIWjdcVT2pXaJ5YDjWzs2LHq2bOnXn/9dSUlJSkzM1OBgYFKTEzUuHHj6lzYHfAE/v7+Wrhwob755ht98skn2r59u/Lz8xUWFqbu3btrzJgxGjlyJFMPgDqEhYXpvffe03vvvacvvvhC+/fvV0lJieLj43XllVfqrrvuUlRUlLPDBJxuyJAh+vrrr7V48WJt2LBBKSkpksp3QRw8eLD+9Kc/qVWrVk6OEnBMVlbWeScMzkW7Ak/QEHXFU9oVRrABAAAAAAAADmANNgAAAAAAAMABJNgAAAAAAAAAB5BgAwAAAAAAABxAgg0AAAAAAABwAAk2AAAAAAAAwAEk2AAAAAAAAAAHkGADAAAAAAAAHECCDQAAAAAAAHAACTYAAAAAAADAASTYAAAAAAAAAAeQYAMAAAAAAAAc4O3sAAAAANB0kpKS9Mc//tHh+0yZMkXz58+XJL399tsaMGCAw/cEAABwV4xgAwAAAAAAABzACDYAAAAP0qVLFy1YsKDG4/fcc48kKTIyUk888USN5+3cubPBYwMAAHBXBovFYnF2EAAAAHAN3bp1kyTFx8drzZo1To4GAADAPTBFFAAAAAAAAHAACTYAAAAAAADAAazBBgAAgPM2b968GncRnTFjhj799FN16NBBy5cvV2pqqt58802tXbtW6enpCgsLU+/evTVp0iT16dNHklRWVqYPPvhAS5cu1YEDB2SxWNSlSxfdeuutGjt2bK2x5OXl6Z133tHatWt1+PBhnT59Wi1atFC/fv108803q3///o33HwEAACASbAAAAGhEP/zwg+677z7l5uZay06cOKFVq1Zp/fr1eumllzRgwAD9+c9/VlJSks21W7du1datW7V7927NnDmz2vt/9913mj59unJycmzKjx8/ruPHj+uLL77Q2LFjNWfOHPn4+DT4+wMAAJBIsAEAAKCRZGdna+rUqSooKNDVV1+twYMHq6SkRF9++aV+/vlnmUwm/f3vf1dCQoKSkpKUmJioMWPGKDw8XL/88ovee+89lZWVafHixbrhhhuUkJBgc/9NmzZp8uTJMplMMhqNGj58uC6//HIFBwfr4MGDWrp0qVJSUrR06VIVFxfr3//+t5P+JwAAQHNHgg0AAACNomJU2bPPPqsbbrjBWn7TTTfp97//vXbt2qW0tDSlpaVp9OjReuaZZ2Q0li8RPGrUKHXs2FFz5syRJK1YscImwXb69Gk99NBDMplMCggI0MKFCzVw4ECb17/zzjt1//33a/Xq1frqq680bNgwXXvttY37pgEAgEdikwMAAAA0miFDhtgk1yTJx8dHY8aMsT4PCQnR448/bk2uVbjhhhusZfv27bM5tmzZMqWnp0uSHnjggSrJNUny8/PT3LlzFRYWJkl67bXXHH4/AAAA1SHBBgAAgEZT04ix1q1bWx8PHDhQgYGBVc4JCgqyJsfy8/Ntji1fvlyS5OXlZZOsO1dYWJiGDRsmSUpOTtaJEyfO7w0AAADYgSmiAAAAaDQdO3astjwkJMT6uE2bNjVeHxAQoOzsbJnNZpvybdu2WY9v2rSp1hgsFov1cXJyslq2bFln3AAAAOeDBBsAAAAaTcUItNoEBATUeMxgMFQpKygoUEFBgfXxPffcY3c8mZmZdp8LAABgL6aIAgAAoNF4eXk1+D0LCwudci0AAEBNGMEGAAAAt+Lv72993KdPH3344YdOjAYAAIARbAAAAHAzISEh8vX1lSRlZGQ4ORoAAAASbAAAAHAzRqNRPXv2lCQdP35cR48erfX8t956Sw8//LDmz5+vY8eONUWIAADAw5BgAwAAgNsZOnSo9fEbb7xR43l5eXl66aWX9Nlnn2nhwoW1bqgAAABQXyTYAAAA4HZuvvlm6w6l7733nt5///0q55SUlGjatGnWHUdHjx6tyMjIJo0TAAB4BjY5AAAAgNsJCwvT008/ralTp8psNuuxxx7T119/rauvvlrh4eE6fPiwPv74Y+uU0JiYGP31r391ctQAAKC5IsEGAAAAtzRs2DC98MIL+tvf/qaCggIlJSUpKSmpynkdOnTQokWLGL0GAAAaDQk2AAAAuK2rr75aF198sf773//q22+/1eHDh1VQUKDg4GB169ZNI0aM0I033ig/Pz9nhwoAAJoxg8VisTg7CAAAAAAAAMBdsckBAAAAAAAA4AASbAAAAAAAAIADSLABAAAAAAAADiDBBgAAAAAAADiABBsAAAAAAADgABJsAAAAAAAAgANIsAEAAAAAAAAOIMEGAAAAAAAAOIAEGwAAAAAAAOAAEmwAAAAAAACAA0iwAQAAAAAAAA4gwQYAAAAAAAA4gAQbAAAAAAAA4AASbAAAAAAAAIAD/h8L7OLA1SsrFwAAAABJRU5ErkJggg==\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_all(one_peak_vector, [-0.02,0.31], \"Single peak\", 0.9, save_path=\"D:\\\\Dropbox\\\\BSC\\\\AI4Media\\\\Plenary 2023\\\\\")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 41, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_threshold(one_peak_vector, title=\"One peak\")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 24, - "outputs": [], - "source": [ - "two_peaks_vector = np.array([8,1,5,35,160,162,45,12,9,4,6,6,3,7,5,2,3,2,57,120,222,78,23,1,9,4], dtype=float)\n", - "two_peaks_vector /= np.sum(two_peaks_vector)\n", - "# print(len(two_peaks_vector))\n", - "# plt.plot(two_peaks_vector, '.-', color='#912916')\n", - "# plt.ylim([0,0.31])" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 133, - "outputs": [ - { - "data": { - "text/plain": "{'left_core': 0.05982905982905984,\n 'right_core': 0.05982905982905984,\n 'middle_core': 0.23076923076923084,\n 'sorted_core': 0.6153846153846154}" - }, - "execution_count": 133, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_all(two_peaks_vector, [0,0.31], \"Two peaks\", 0.9, save_path=\"D:\\\\Dropbox\\\\BSC\\\\AI4Media\\\\Plenary 2023\\\\\")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 42, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_threshold(two_peaks_vector, title=\"Two peaks\")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 27, - "outputs": [], - "source": [ - "np.random.seed(1101)\n", - "uni = np.random.uniform(2, 8, (26,))" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 28, - "outputs": [], - "source": [ - "uniform = uni.copy()\n", - "uniform[20] = 11.\n", - "uniform /= np.sum(uniform)\n", - "# print(len(uniform))\n", - "# plt.plot(uniform, '.-', color='#912916')\n", - "# plt.ylim([0,0.31])" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 134, - "outputs": [ - { - "data": { - "text/plain": "{'left_core': 0.0,\n 'right_core': 0.0,\n 'middle_core': 0.0,\n 'sorted_core': 0.1826923076923077}" - }, - "execution_count": 134, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_all(uniform, [0,0.31], \"Uniform\", 0.8, save_path=\"D:\\\\Dropbox\\\\BSC\\\\AI4Media\\\\Plenary 2023\\\\\")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 43, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_threshold(uniform, title=\"Uniform\")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} From 9e48b5ea57538cf3c7e468bb2ee95a1377d2a225 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Fri, 14 Apr 2023 17:37:30 +0200 Subject: [PATCH 05/11] Update setup.py, fix ephemerality-cmd.py. --- .gitignore | 3 +- Dockerfile | 14 ++-- ephemerality.egg-info/PKG-INFO | 40 ++++++++-- ephemerality.egg-info/SOURCES.txt | 15 +++- ephemerality.egg-info/requires.txt | 8 ++ ephemerality.egg-info/top_level.txt | 4 +- ephemerality/__init__.py | 4 +- ephemerality/data_processing.py | 93 +++++++++++++++++------- ephemerality/ephemerality_computation.py | 48 ++++++------ requirements-test.txt | 2 + requirements.txt | 6 +- rest/api_versions/api11.py | 2 +- scripts/ephemerality-api.py | 3 +- scripts/ephemerality-cmd.py | 68 ++++++++++------- setup.py | 18 ++++- testing/test_ephemerality.py | 2 +- 16 files changed, 221 insertions(+), 109 deletions(-) create mode 100644 ephemerality.egg-info/requires.txt create mode 100644 requirements-test.txt diff --git a/.gitignore b/.gitignore index a3f4c77..e4578ef 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,5 @@ /venv/ **/tmp_* **/tmp-* -/testing/test_data/ \ No newline at end of file +/testing/test_data/ +/testing/test_output/ diff --git a/Dockerfile b/Dockerfile index d002053..7832d7a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,13 +1,15 @@ FROM python:3.9.15-slim +ARG test=false -ADD ephemerality /src -ADD testing /test +ADD ephemerality /ephemerality +ADD ephemerality.egg-info /ephemerality.egg-info ADD rest /rest -ADD scripts/ephemerality-cmd.py / -ADD requirements.txt / +ADD scripts /scripts +ADD testing /testing ADD _version.py / +ADD README.md / ADD setup.py / -RUN pip install --no-cache-dir --upgrade -r requirements.txt +RUN if [ $test = true ] ; then pip install --no-cache-dir --upgrade -e .[test] ; else pip install --no-cache-dir --upgrade .; fi -CMD ["uvicorn", "rest.api:app", "--host", "0.0.0.0", "--port", "8080"] +ENTRYPOINT ["uvicorn", "scripts.ephemerality-api:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/ephemerality.egg-info/PKG-INFO b/ephemerality.egg-info/PKG-INFO index 47c2ad3..67ff58f 100644 --- a/ephemerality.egg-info/PKG-INFO +++ b/ephemerality.egg-info/PKG-INFO @@ -1,19 +1,39 @@ Metadata-Version: 2.1 Name: ephemerality -Version: 1.0.0 +Version: 1.1.0 Summary: Module for computing ephemerality metrics of temporal arrays. Home-page: https://github.com/HPAI-BSC/ephemerality Author: HPAI BSC Author-email: dmitry.gnatyshak@bsc.es License: MIT -Platform: UNKNOWN +Provides-Extra: test # Ephemerality metric In [[1]](#1) we formalized the ephemerality metrics used to estimate the healthiness of online discussions. It shows how 'ephemeral' topics are, that is whether the discussions are more or less uniformly active or only revolve around one or several peaks of activity. -### Requirements +We defined 3 versions of ephemerality: original, filtered, and sorted. Let us suppose we have a discussion that we can divide in $N$ bins of equal time length and for each bin we can calculate activity in that time period (e.g. number of tweets, watches, visits etc.). Let $t$ denote a normalized vector of frequency corresponding to this discussion, $t_i$ corresponds to normalized activity in during time bin $i$. Let $\alpha\in\left[0, 1\right)$ denote a parameter showing which portion of activity we consider to be the "core" activity. Then we can define ephemerality as a normalized portion of $t$ that contains the remaining $1-\alpha$ activity. We can interpret this defenition in three slightly different ways depending on what we consider to be the core activity: + +1. **Original ephemerality**. We calculate core activity as the minimal portion of $t$ starting from the beginning of the vector that contains at least $\alpha$ of the total activity (which is 1 in case of normalized $t$). Then the ephemerality formula can be computed as follows: + +$$ +\varepsilon_{orig}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} t_i \right) \ge \alpha}{N} +$$ + +2. **Filtered ephemerality**. We calculate core activity the minimal *central* portion of $t$ that contains at least $\alpha$ of the total activity. For that we exclude portions of $t$ from the beginning and the end of $t$, so that the sum of each of these portions is as close to $\frac{1-\alpha}{2}$ as possible without reaching it: + +$$ +\varepsilon_{filt}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} t_i - \max_{p\in [1,N]}: \left( \sum_{j=1\dots p} t_j \right) < \frac{1-\alpha}{2} \right) \ge \alpha}{N} +$$ + +3. **Sorted ephemerality**. Finally, we can define the core activity as the minimal number of time bins that cover $\alpha$ portion of the activity. For that we sort $t$ components in descending order (denoted as $\widehat{t}$) and then apply the formula of original ephemerality: + +$$ +\varepsilon_{sort}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} \widehat{t}_i \right) \ge \alpha}{N} +$$ + +## Requirements The code was tested to work with Python 3.8.6 and Numpy 1.21.5, but is expected to also run on their older versions. ## How to run the experiments @@ -35,9 +55,14 @@ to 0.8. * **Print**. `[-p, --print]`. _Optional_. If output file is provided, forces the results to still be printed to stdout. ### Output -If no output file specified or `-p` option is used, results are printed to STDOUT in **[εorig -εorig_span εfiltered εfiltered_span εsorted εsorted_span]** -format, one line per each line of input file (or a single line for command line input). +If no output file specified or `-p` option is used, results are printed to STDOUT in [ +$\varepsilon_{orig}$ ␣ +span( $\varepsilon_{orig}$ ) ␣ +$\varepsilon_{filt}$ ␣ +span( $\varepsilon_{filt}$ ) ␣ +$\varepsilon_{sort}$ ␣ +span( $\varepsilon_{sort}$ ) +] format, one line per each line of input file (or a single line for command line input). If the output file was specified among the input arguments, the results will be written into that file in JSON format as a list of dictionaries, one per input line: @@ -61,6 +86,7 @@ a list of dictionaries, one per input line: Input file `test_input.csv`: ``` 0.0,0.0,0.0,0.2,0.55,0.0,0.15,0.1,0.0,0.0 +0,1,1.,0.0,.0 ``` #### Python execution: @@ -147,5 +173,3 @@ Output: ## References [1] Gnatyshak, D., Garcia-Gasulla, D., Alvarez-Napagao, S., Arjona, J., & Venturini, T. (2022). Healthy Twitter discussions? Time will tell. arXiv preprint arXiv:2203.11261 - - diff --git a/ephemerality.egg-info/SOURCES.txt b/ephemerality.egg-info/SOURCES.txt index 1d38aee..6f2e026 100644 --- a/ephemerality.egg-info/SOURCES.txt +++ b/ephemerality.egg-info/SOURCES.txt @@ -1,10 +1,17 @@ README.md setup.py +ephemerality/__init__.py +ephemerality/data_processing.py +ephemerality/ephemerality_computation.py +ephemerality/utils.py ephemerality.egg-info/PKG-INFO ephemerality.egg-info/SOURCES.txt ephemerality.egg-info/dependency_links.txt +ephemerality.egg-info/requires.txt ephemerality.egg-info/top_level.txt -src/__init__.py -src/ephemerality_computation.py -test/__init__.py -test/test_ephemerality.py \ No newline at end of file +scripts/ephemerality-api.py +scripts/ephemerality-cmd.py +testing/__init__.py +testing/data_generator.py +testing/test_ephemerality.py +testing/test_utils.py \ No newline at end of file diff --git a/ephemerality.egg-info/requires.txt b/ephemerality.egg-info/requires.txt new file mode 100644 index 0000000..87ce2ac --- /dev/null +++ b/ephemerality.egg-info/requires.txt @@ -0,0 +1,8 @@ +numpy==1.24.2 +fastapi==0.95.0 +setuptools==67.6.1 +pydantic==1.10.7 + +[test] +matplotlib==3.7.1 +requests==2.28.2 diff --git a/ephemerality.egg-info/top_level.txt b/ephemerality.egg-info/top_level.txt index 281df39..ca2f85f 100644 --- a/ephemerality.egg-info/top_level.txt +++ b/ephemerality.egg-info/top_level.txt @@ -1,2 +1,2 @@ -src -test +ephemerality +testing diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py index 5ad0400..f74e392 100644 --- a/ephemerality/__init__.py +++ b/ephemerality/__init__.py @@ -1,5 +1,5 @@ from ephemerality.ephemerality_computation import compute_ephemerality -from ephemerality.data_processing import process_input, InputData +from ephemerality.data_processing import process_input, InputData, ProcessedData from ephemerality.utils import ResultSet -__all__ = [compute_ephemerality, ResultSet, process_input, InputData] +__all__ = [compute_ephemerality, ResultSet, process_input, InputData, ProcessedData] diff --git a/ephemerality/data_processing.py b/ephemerality/data_processing.py index f7ce642..3f688cb 100644 --- a/ephemerality/data_processing.py +++ b/ephemerality/data_processing.py @@ -5,6 +5,7 @@ from typing import Sequence import json import warnings +from dataclasses import dataclass SECONDS_WEEK = 604800. @@ -17,12 +18,21 @@ class InputData(BaseModel): POST request body format """ input: list[str] - input_type: str = 'f' # 'frequencies' | 'f' | 'timestamps' | 't' | 'datetime' | 'd' + input_type: str = 'a' # 'activity' | 'a' | 'timestamps' | 't' | 'datetime' | 'd' threshold: float = 0.8 time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format timezone: float = 0. # used only if input_type == 'datetime' | 'd'. Offset in hours from the UTC time. Should be within [-24, +24] range. - range: None | tuple[str, str] = None # used only if input_type == 'timestamps' | 't', defaults to (min(timestamps), max(timestamps) + 1) - granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't'. {'week', 'day', 'hour', '_d', '_h'} + range: None | tuple[str, str] = None # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd', + # defaults to (min(input), max(input)) + granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd'. {'week', 'day', 'hour', '_d', '_h'} + reference_name: str = "" + + +@dataclass +class ProcessedData: + name: str + activity: np.ndarray[float] + threshold: float = 0.8 def process_input( @@ -32,7 +42,7 @@ def process_input( input_remote_data: InputData | None = None, input_dict: dict | None = None, input_seq: Sequence[float | int | str] | None = None, - threshold: float=0.8) -> list[tuple[np.ndarray[float], float]]: + threshold: float=0.8) -> list[ProcessedData]: output = [] if input_folder: @@ -42,19 +52,19 @@ def process_input( output.extend(process_file(path=Path(input_file), threshold=threshold)) if input_remote_data: - output.extend(process_formatted_data(input_remote_data)) + output.append(process_formatted_data(input_remote_data)) if input_dict: - output.extend(process_formatted_data(InputData(**input_dict))) + output.append(process_formatted_data(InputData(**input_dict))) if input_seq: if threshold is None: raise ValueError('Threshold value is not defined!') - output.append((np.ndarray(input_seq, dtype=float), threshold)) + output.append(ProcessedData(name="sequence", activity=np.ndarray(input_seq, dtype=float), threshold=threshold)) return output -def process_folder(path: Path, recursive: bool = True, threshold: float | None = None) -> list[tuple[np.ndarray[float], float]]: +def process_folder(path: Path, recursive: bool = True, threshold: float | None = None) -> list[ProcessedData]: output = [] for file in path.iterdir(): if file.is_file(): @@ -64,16 +74,17 @@ def process_folder(path: Path, recursive: bool = True, threshold: float | None = return output -def process_file(path: Path, threshold: float | None = None) -> list[tuple[np.ndarray[float], float]]: +def process_file(path: Path, threshold: float | None = None) -> list[ProcessedData]: if path.suffix == '.json': return process_json(path) elif path.suffix == '.csv': - return [(sequence, threshold) for sequence in process_csv(path)] + return [ProcessedData(name=f"{str(path.absolute())}[{i}]", activity=sequence, threshold=threshold) + for i, sequence in enumerate(process_csv(path))] else: return [] -def process_json(path: Path) -> list[tuple[np.ndarray[float], float]]: +def process_json(path: Path) -> list[ProcessedData]: with open(path, 'r') as f: input_object = json.load(f) @@ -81,27 +92,52 @@ def process_json(path: Path) -> list[tuple[np.ndarray[float], float]]: input_object = [input_object] output = [] - for input_case in input_object: + for i, input_case in enumerate(input_object): input_case = InputData(**input_case) try: - process_formatted_data(input_case) + case_output = process_formatted_data(input_case) + if not case_output.name: + case_output.name = f"{str(path.absolute())}[{i}]" + output.append(case_output) except ValueError: - warnings.warn(f'\"input_type\" is not one of ["frequencies", "f", "timestamps", "t"]! Ignoring file \"{str(path.absolute())}\"!') + warnings.warn(f'\"input_type\" is not one of [\"activity\", \"a\", \"timestamps\", \"t\", \"datetime\", \"d\"]!' + f' Ignoring file \"{str(path.absolute())}\"!') return output -def process_formatted_data(input_data: InputData) -> tuple[np.ndarray[float], float]: - if input_data.input_type == 'frequencies' or input_data.input_type == 'f': - return np.array(input_data.input), input_data.threshold +def process_formatted_data(input_data: InputData) -> ProcessedData: + if input_data.input_type == 'activity' or input_data.input_type == 'a': + return ProcessedData( + name=input_data.reference_name, + activity=np.array(input_data.input, dtype=float), + threshold=input_data.threshold + ) elif input_data.input_type == 'timestamps' or input_data.input_type == 't': - return timestamps_to_frequencies(np.array(input_data.input, dtype=float), input_data.range, - input_data.granularity), input_data.threshold + return ProcessedData( + name=input_data.reference_name, + activity=timestamps_to_activity(np.array(input_data.input, dtype=float), + input_data.range, + input_data.granularity), + threshold=input_data.threshold + ) elif input_data.input_type == 'datetime' or input_data.input_type == 'd': timestamps = [datetime.strptime(time_point, input_data.time_format).replace(tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() for time_point in input_data.input] - return timestamps_to_frequencies(np.array(timestamps, dtype=float), input_data.range, - input_data.granularity), input_data.threshold + if input_data.range is not None: + ts_range = ( + datetime.strptime(input_data.range[0], input_data.time_format).replace( + tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp(), + datetime.strptime(input_data.range[1], input_data.time_format).replace( + tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() + ) + else: + ts_range = None + return ProcessedData( + name=input_data.reference_name, + activity=timestamps_to_activity(np.array(timestamps, dtype=float), ts_range, input_data.granularity), + threshold=input_data.threshold + ) else: raise ValueError("Wrong \"input_type\" value!") @@ -115,9 +151,9 @@ def process_csv(path: Path) -> list[np.ndarray[float]]: return output -def timestamps_to_frequencies(timestamps: Sequence[float | int | str], - ts_range: None | tuple[float | int | str, float | int | str] = None, - granularity: str = 'day') -> np.ndarray[float]: +def timestamps_to_activity(timestamps: Sequence[float | int | str], + ts_range: None | tuple[float | int | str, float | int | str] = None, + granularity: str = 'day') -> np.ndarray[float]: if not isinstance(timestamps, np.ndarray) or timestamps.dtype != float: timestamps = np.array(timestamps, dtype=float) if ts_range is None: @@ -135,17 +171,20 @@ def timestamps_to_frequencies(timestamps: Sequence[float | int | str], else: raise ValueError(f"Invalid granularity value: {granularity}!") + # print(f"\n\nDEBUG: ts_range[0]: {ts_range[0]}, ts_range[1]: {ts_range[1]}, bin_width: {bin_width}\n\n") + bins = np.arange(ts_range[0], ts_range[1], bin_width) if not np.isclose(bins[-1], ts_range[1]): bins = np.append(bins, ts_range[1]) - frequency, _ = np.histogram(np.array(timestamps, dtype=float), bins=bins) - return frequency + activity, _ = np.histogram(np.array(timestamps, dtype=float), bins=bins) + activity.dtype = float + return activity def _is_float(num: str) -> bool: try: - tmp = float(num) + float(num) except ValueError: return False return True diff --git a/ephemerality/ephemerality_computation.py b/ephemerality/ephemerality_computation.py index 5973856..056ad29 100644 --- a/ephemerality/ephemerality_computation.py +++ b/ephemerality/ephemerality_computation.py @@ -15,21 +15,21 @@ def _check_threshold(threshold: float) -> bool: def _ephemerality_raise_error(threshold: float): if _check_threshold(threshold): - raise ValueError('Input frequency vector has not been internally normalized (problematic data format?)!') + raise ValueError('Input activity vector has not been internally normalized (problematic data format?)!') -def _normalize_frequency_vector(frequency_vector: Sequence[float]) -> np.array: - frequency_vector = np.array(frequency_vector) +def _normalize_activity_vector(activity_vector: Sequence[float]) -> np.array: + activity_vector = np.array(activity_vector) - if sum(frequency_vector) != 1.: - frequency_vector /= np.sum(frequency_vector) + if sum(activity_vector) != 1.: + activity_vector /= np.sum(activity_vector) - return frequency_vector + return activity_vector -def compute_left_core_length(frequency_vector: np.array, threshold: float) -> int: +def compute_left_core_length(activity_vector: np.array, threshold: float) -> int: current_sum = 0 - for i, freq in enumerate(frequency_vector): + for i, freq in enumerate(activity_vector): current_sum = current_sum + freq if np.isclose(current_sum, threshold) or current_sum > threshold: return i + 1 @@ -37,9 +37,9 @@ def compute_left_core_length(frequency_vector: np.array, threshold: float) -> in _ephemerality_raise_error(threshold) -def compute_right_core_length(frequency_vector: np.array, threshold: float) -> int: +def compute_right_core_length(activity_vector: np.array, threshold: float) -> int: current_sum = 0 - for i, freq in enumerate(frequency_vector[::-1]): + for i, freq in enumerate(activity_vector[::-1]): current_sum = current_sum + freq if np.isclose(current_sum, threshold) or current_sum > threshold: return i + 1 @@ -47,19 +47,19 @@ def compute_right_core_length(frequency_vector: np.array, threshold: float) -> i _ephemerality_raise_error(threshold) -def compute_middle_core_length(frequency_vector: np.array, threshold: float) -> int: +def compute_middle_core_length(activity_vector: np.array, threshold: float) -> int: lower_threshold = (1. - threshold) / 2 current_presum = 0 start_index = -1 - for i, freq in enumerate(frequency_vector): + for i, freq in enumerate(activity_vector): current_presum += freq if current_presum > lower_threshold and not np.isclose(current_presum, lower_threshold): start_index = i break current_sum = 0 - for j, freq in enumerate(frequency_vector[start_index:]): + for j, freq in enumerate(activity_vector[start_index:]): current_sum += freq if np.isclose(current_sum, threshold) or current_sum > threshold: return j + 1 @@ -67,8 +67,8 @@ def compute_middle_core_length(frequency_vector: np.array, threshold: float) -> _ephemerality_raise_error(threshold) -def compute_sorted_core_length(frequency_vector: np.array, threshold: float) -> int: - freq_descending_order = np.sort(frequency_vector)[::-1] +def compute_sorted_core_length(activity_vector: np.array, threshold: float) -> int: + freq_descending_order = np.sort(activity_vector)[::-1] current_sum = 0 for i, freq in enumerate(freq_descending_order): @@ -84,41 +84,41 @@ def _compute_ephemerality_from_core(core_length: int, range_length: int, thresho def compute_ephemerality( - frequency_vector: Sequence[float], + activity_vector: Sequence[float], threshold: float = 0.8, types: str = 'lmrs') -> ResultSet: _check_threshold(threshold) - if np.sum(frequency_vector) == 0.: - raise ZeroDivisionError("Frequency vector's sum is 0!") + if np.sum(activity_vector) == 0.: + raise ZeroDivisionError("Activity vector's sum is 0!") - frequency_vector = _normalize_frequency_vector(frequency_vector) - range_length = len(frequency_vector) + activity_vector = _normalize_activity_vector(activity_vector) + range_length = len(activity_vector) if 'l' in types: - length_left_core = compute_left_core_length(frequency_vector, threshold) + length_left_core = compute_left_core_length(activity_vector, threshold) ephemerality_left_core = _compute_ephemerality_from_core(length_left_core, range_length, threshold) else: length_left_core = None ephemerality_left_core = None if 'm' in types: - length_middle_core = compute_middle_core_length(frequency_vector, threshold) + length_middle_core = compute_middle_core_length(activity_vector, threshold) ephemerality_middle_core = _compute_ephemerality_from_core(length_middle_core, range_length, threshold) else: length_middle_core = None ephemerality_middle_core = None if 'r' in types: - length_right_core = compute_right_core_length(frequency_vector, threshold) + length_right_core = compute_right_core_length(activity_vector, threshold) ephemerality_right_core = _compute_ephemerality_from_core(length_right_core, range_length, threshold) else: length_right_core =None ephemerality_right_core = None if 's' in types: - length_sorted_core = compute_sorted_core_length(frequency_vector, threshold) + length_sorted_core = compute_sorted_core_length(activity_vector, threshold) ephemerality_sorted_core = _compute_ephemerality_from_core(length_sorted_core, range_length, threshold) else: length_sorted_core = None diff --git a/requirements-test.txt b/requirements-test.txt new file mode 100644 index 0000000..5c532c4 --- /dev/null +++ b/requirements-test.txt @@ -0,0 +1,2 @@ +matplotlib==3.7.1 +requests==2.28.2 \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index b7645fc..ceafe93 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,8 +1,4 @@ numpy==1.24.2 fastapi==0.95.0 setuptools==67.6.1 -pydantic==1.10.7 -matplotlib[test]==3.7.1 -requests[test]==2.28.2 - -ephemerality~=1.0.0 \ No newline at end of file +pydantic==1.10.7 \ No newline at end of file diff --git a/rest/api_versions/api11.py b/rest/api_versions/api11.py index f22b682..c8c2116 100644 --- a/rest/api_versions/api11.py +++ b/rest/api_versions/api11.py @@ -16,4 +16,4 @@ def get_ephemerality(self, threshold: Annotated[float, Query(gt=0., le=1.)], types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] ) -> ResultSet: - return compute_ephemerality(frequency_vector=input_vector, threshold=threshold, types=types) \ No newline at end of file + return compute_ephemerality(activity_vector=input_vector, threshold=threshold, types=types) \ No newline at end of file diff --git a/scripts/ephemerality-api.py b/scripts/ephemerality-api.py index c757f92..2f74d0f 100644 --- a/scripts/ephemerality-api.py +++ b/scripts/ephemerality-api.py @@ -1,4 +1,5 @@ -from rest import api +#!/usr/bin/env python + from fastapi import FastAPI import sys from rest import set_test_mode, router diff --git a/scripts/ephemerality-cmd.py b/scripts/ephemerality-cmd.py index 36d506d..9be2e2d 100644 --- a/scripts/ephemerality-cmd.py +++ b/scripts/ephemerality-cmd.py @@ -1,21 +1,24 @@ -import time +#!/usr/bin/env python -from _version import __version__ -import sys -from typing import Union -import json import argparse +import json +import sys +import time from argparse import Namespace -import numpy as np from pathlib import Path +from typing import Union + +import numpy as np from memory_profiler import memory_usage -from ephemerality import compute_ephemerality, process_input + +from _version import __version__ +from ephemerality import compute_ephemerality, process_input, ProcessedData def init_argparse() -> argparse.ArgumentParser: parser = argparse.ArgumentParser( - usage="%(prog)s [FREQUENCY_VECTOR] [-h] [-v] [-i INPUT_FILE] [-o OUTPUT_FILE.json] [-t THRESHOLD]...", - description="Calculate ephemerality for a given vector of frequencies." + usage="%(prog)s [ACTIVITY_VECTOR] [-h] [-v] [-i INPUT_FILE] [-o OUTPUT_FILE.json] [-t THRESHOLD]...", + description="Calculate ephemerality for a given activity vector or a set of timestamps." ) parser.add_argument( "-v", "--version", action="version", @@ -28,7 +31,7 @@ def init_argparse() -> argparse.ArgumentParser: parser.add_argument( "-i", "--input", action="store", help="Path to either a JSON or CSV file with input data, or to the folder with files. If not specified, " - "will read the frequency vector from the command line (delimited either by commas or spaces)." + "will read the activity vector from the command line (delimited either by commas or spaces)." ) parser.add_argument( "-r", "--recursive", action="store_true", @@ -53,8 +56,8 @@ def init_argparse() -> argparse.ArgumentParser: " output the peak RAM usage instead of ephemerality." ) parser.add_argument( - 'frequencies', type=float, - help='frequency vector (if the input file is not specified)', + 'activity', type=float, + help='Activity vector (if the input file is not specified)', nargs='*' ) return parser @@ -66,34 +69,47 @@ def run(input_args: Namespace, supress_save_output: bool = False) -> Union[str, if path.is_dir(): input_cases = process_input(input_folder=input_args.input, recursive=input_args.recursive) elif path.is_file(): - input_cases = process_input(input_file=input_args.input) + input_cases = process_input(input_file=input_args.input, threshold=float(input_args.threshold)) else: raise ValueError("Unknown input file format!") else: - input_cases: list[tuple[np.ndarray, float]] = [] - if len(input_args.frequencies) > 1: - input_cases.append((np.array(input_args.frequencies, dtype=float), float(input_args.threshold))) - elif len(input_args.frequencies) == 1: - if ' ' in input_args.frequencies[0]: - input_cases.append((np.array(input_args.frequencies[0].split(' '), dtype=float), float(input_args.threshold))) + input_cases: list[ProcessedData] = [] + if len(input_args.activity) > 1: + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array(input_args.activity, dtype=float), + threshold=float(input_args.threshold))) + elif len(input_args.activity) == 1: + if ' ' in input_args.activity[0]: + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array(input_args.activity[0].split(' '), dtype=float), + threshold=float(input_args.threshold))) else: - input_cases.append((np.array(input_args.frequencies[0].split(','), dtype=float), float(input_args.threshold))) + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array(input_args.activity[0].split(','), dtype=float), + threshold=float(input_args.threshold))) else: sys.exit('No input provided!') - ephemerality_list = list() - for frequency_vector, threshold in input_cases: - ephemerality_list.append(compute_ephemerality(frequency_vector=frequency_vector, threshold=threshold).dict()) + results = {} + for input_case in input_cases: + results[input_case.name] = (compute_ephemerality(activity_vector=input_case.activity, + threshold=input_case.threshold).dict()) if input_args.output and not supress_save_output: with open(input_args.output, 'w+') as f: - json.dump(ephemerality_list, f, indent=2) + json.dump(results, f, indent=2) if input_args.print: - return json.dumps(ephemerality_list, indent=2) + return json.dumps(results, indent=2) else: return None else: - return json.dumps(ephemerality_list, indent=2) + return json.dumps(results, indent=2) if __name__ == '__main__': diff --git a/setup.py b/setup.py index 37cf640..263538a 100644 --- a/setup.py +++ b/setup.py @@ -26,5 +26,21 @@ def read(file_name): author='HPAI BSC', author_email='dmitry.gnatyshak@bsc.es', description='Module for computing ephemerality metrics of temporal arrays.', - long_description=read('README.md') + long_description=read('README.md'), + scripts=[ + 'scripts/ephemerality-api.py', + 'scripts/ephemerality-cmd.py' + ], + install_requires=[ + 'numpy==1.24.2', + 'fastapi==0.95.0', + 'setuptools==67.6.1', + 'pydantic==1.10.7' + ], + extras_require={ + 'test':[ + 'matplotlib==3.7.1', + 'requests==2.28.2' + ] + } ) diff --git a/testing/test_ephemerality.py b/testing/test_ephemerality.py index 8c4bf2e..57e3b1e 100644 --- a/testing/test_ephemerality.py +++ b/testing/test_ephemerality.py @@ -658,7 +658,7 @@ def test_compute_ephemeralities(self): with self.subTest(): print(f'\nRunning test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') - actual_output = compute_ephemerality(frequency_vector=test_case.input_sequence, + actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, threshold=test_case.threshold) try: From 641332681c19ed09b32339ad6089d24d3a4ad1d0 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 18 Apr 2023 18:01:44 +0200 Subject: [PATCH 06/11] Resturcuture project, streamline argument parsing. --- .gitignore | 17 +- LICENSE | 21 + README.md | 2 +- _version.py | 2 +- ephemerality.egg-info/PKG-INFO | 175 ----- ephemerality.egg-info/SOURCES.txt | 17 - ephemerality.egg-info/dependency_links.txt | 1 - ephemerality.egg-info/requires.txt | 8 - ephemerality.egg-info/top_level.txt | 2 - ephemerality/__init__.py | 8 +- ephemerality/__main__.py | 36 + ephemerality/ephemerality/__init__.py | 5 + .../{ => ephemerality}/data_processing.py | 15 +- .../ephemerality_computation.py | 8 +- ephemerality/{ => ephemerality}/utils.py | 0 {rest => ephemerality/rest}/__init__.py | 4 +- {rest => ephemerality/rest}/api.py | 8 +- .../rest}/api_versions/__init__.py | 0 .../rest}/api_versions/api11.py | 2 +- .../rest}/api_versions/api_template.py | 2 +- ephemerality/rest/runner.py | 6 + ephemerality/scripts/__init__.py | 5 + ephemerality/scripts/ephemerality_api.py | 34 + .../scripts/ephemerality_cmd.py | 111 ++- requirements-test.txt | 4 +- requirements.txt | 9 +- scripts/ephemerality-api.py | 13 - scripts/test_performance.py | 165 ----- setup.py | 24 +- testing/__init__.py | 4 - testing/data_generator.py | 37 - testing/test_ephemerality.py | 670 ------------------ testing/test_utils.py | 10 - 33 files changed, 211 insertions(+), 1214 deletions(-) create mode 100644 LICENSE delete mode 100644 ephemerality.egg-info/PKG-INFO delete mode 100644 ephemerality.egg-info/SOURCES.txt delete mode 100644 ephemerality.egg-info/dependency_links.txt delete mode 100644 ephemerality.egg-info/requires.txt delete mode 100644 ephemerality.egg-info/top_level.txt create mode 100644 ephemerality/__main__.py create mode 100644 ephemerality/ephemerality/__init__.py rename ephemerality/{ => ephemerality}/data_processing.py (92%) rename ephemerality/{ => ephemerality}/ephemerality_computation.py (95%) rename ephemerality/{ => ephemerality}/utils.py (100%) rename {rest => ephemerality/rest}/__init__.py (88%) rename {rest => ephemerality/rest}/api.py (94%) rename {rest => ephemerality/rest}/api_versions/__init__.py (100%) rename {rest => ephemerality/rest}/api_versions/api11.py (94%) rename {rest => ephemerality/rest}/api_versions/api_template.py (94%) create mode 100644 ephemerality/rest/runner.py create mode 100644 ephemerality/scripts/__init__.py create mode 100644 ephemerality/scripts/ephemerality_api.py rename scripts/ephemerality-cmd.py => ephemerality/scripts/ephemerality_cmd.py (52%) delete mode 100644 scripts/ephemerality-api.py delete mode 100644 scripts/test_performance.py delete mode 100644 testing/__init__.py delete mode 100644 testing/data_generator.py delete mode 100644 testing/test_ephemerality.py delete mode 100644 testing/test_utils.py diff --git a/.gitignore b/.gitignore index e4578ef..78190b6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,11 +1,12 @@ -/tmp/ +**/tmp/ **/.pytest_cache/ -**/*.json -**/*.pyc -**/*.idea/ -/build/ -/venv/ +*.json +*.pyc +*.idea/ +**/build/ +**/venv/ **/tmp_* **/tmp-* -/testing/test_data/ -/testing/test_output/ +**/testing/ +**/test/ +**/*.egg-info/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..276376f --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Barcelona Supercomputing Center - Centro Nacional de Supercomputación (BSC-CNS) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index e7ad269..d4fbe6f 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ In [[1]](#1) we formalized the ephemerality metrics used to estimate the healthi 'ephemeral' topics are, that is whether the discussions are more or less uniformly active or only revolve around one or several peaks of activity. -We defined 3 versions of ephemerality: original, filtered, and sorted. Let us suppose we have a discussion that we can divide in $N$ bins of equal time length and for each bin we can calculate activity in that time period (e.g. number of tweets, watches, visits etc.). Let $t$ denote a normalized vector of frequency corresponding to this discussion, $t_i$ corresponds to normalized activity in during time bin $i$. Let $\alpha\in\left[0, 1\right)$ denote a parameter showing which portion of activity we consider to be the "core" activity. Then we can define ephemerality as a normalized portion of $t$ that contains the remaining $1-\alpha$ activity. We can interpret this defenition in three slightly different ways depending on what we consider to be the core activity: +We defined 3 versions of ephemerality: original, filtered, and sorted. Let us suppose we have a discussion that we can divide in $N$ bins of equal time length and for each bin we can calculate activity in that time period (e.g. number of tweets, watches, visits etc.). Let $t$ denote a normalized vector of frequency corresponding to this discussion, $t_i$ corresponds to normalized activity in during time bin $i$. Let $\alpha\in\left[0, 1\right)$ denote a parameter showing which portion of activity we consider to be the "core" activity. Then we can define ephemerality as a normalized portion of $t$ that contains the remaining $1-\alpha$ activity. We can interpret this definition in three slightly different ways depending on what we consider to be the core activity: 1. **Original ephemerality**. We calculate core activity as the minimal portion of $t$ starting from the beginning of the vector that contains at least $\alpha$ of the total activity (which is 1 in case of normalized $t$). Then the ephemerality formula can be computed as follows: diff --git a/_version.py b/_version.py index ff1068c..6849410 100644 --- a/_version.py +++ b/_version.py @@ -1 +1 @@ -__version__ = "1.1.0" \ No newline at end of file +__version__ = "1.1.0" diff --git a/ephemerality.egg-info/PKG-INFO b/ephemerality.egg-info/PKG-INFO deleted file mode 100644 index 67ff58f..0000000 --- a/ephemerality.egg-info/PKG-INFO +++ /dev/null @@ -1,175 +0,0 @@ -Metadata-Version: 2.1 -Name: ephemerality -Version: 1.1.0 -Summary: Module for computing ephemerality metrics of temporal arrays. -Home-page: https://github.com/HPAI-BSC/ephemerality -Author: HPAI BSC -Author-email: dmitry.gnatyshak@bsc.es -License: MIT -Provides-Extra: test - -# Ephemerality metric -In [[1]](#1) we formalized the ephemerality metrics used to estimate the healthiness of online discussions. It shows how -'ephemeral' topics are, that is whether the discussions are more or less uniformly active or only revolve around one or -several peaks of activity. - -We defined 3 versions of ephemerality: original, filtered, and sorted. Let us suppose we have a discussion that we can divide in $N$ bins of equal time length and for each bin we can calculate activity in that time period (e.g. number of tweets, watches, visits etc.). Let $t$ denote a normalized vector of frequency corresponding to this discussion, $t_i$ corresponds to normalized activity in during time bin $i$. Let $\alpha\in\left[0, 1\right)$ denote a parameter showing which portion of activity we consider to be the "core" activity. Then we can define ephemerality as a normalized portion of $t$ that contains the remaining $1-\alpha$ activity. We can interpret this defenition in three slightly different ways depending on what we consider to be the core activity: - -1. **Original ephemerality**. We calculate core activity as the minimal portion of $t$ starting from the beginning of the vector that contains at least $\alpha$ of the total activity (which is 1 in case of normalized $t$). Then the ephemerality formula can be computed as follows: - -$$ -\varepsilon_{orig}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} t_i \right) \ge \alpha}{N} -$$ - -2. **Filtered ephemerality**. We calculate core activity the minimal *central* portion of $t$ that contains at least $\alpha$ of the total activity. For that we exclude portions of $t$ from the beginning and the end of $t$, so that the sum of each of these portions is as close to $\frac{1-\alpha}{2}$ as possible without reaching it: - -$$ -\varepsilon_{filt}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} t_i - \max_{p\in [1,N]}: \left( \sum_{j=1\dots p} t_j \right) < \frac{1-\alpha}{2} \right) \ge \alpha}{N} -$$ - -3. **Sorted ephemerality**. Finally, we can define the core activity as the minimal number of time bins that cover $\alpha$ portion of the activity. For that we sort $t$ components in descending order (denoted as $\widehat{t}$) and then apply the formula of original ephemerality: - -$$ -\varepsilon_{sort}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} \widehat{t}_i \right) \ge \alpha}{N} -$$ - -## Requirements -The code was tested to work with Python 3.8.6 and Numpy 1.21.5, but is expected to also run on their older versions. - -## How to run the experiments -The code can be run directly via the calculate_ephemerality.py script or via a Docker container built with the provided -Dockerfile. - -### Input -The script/container expect the following input arguments: - -* **Frequency vector file**. `[-i PATH, --input PATH]` _Optional_. Path to a file containing one or several arrays of -numbers in csv format (one array per line), representing temporal frequency vectors. They do not need to be normalized: -if they are not --- they will be normalized automatically. -* **Frequency vector**. _Optional_. If input file is not provided, a frequency vector is expected as a positional -argument (either comma- or space-separated). -* **Output file**. `[-o PATH, --output PATH]` _Optional_. If it is provided, the results will be written into this file -in JSON format. -* **Threshold**. `[-t FLOAT, -threshold FLOAT]` _Optional_. Threshold value for ephemerality computations. Defaults -to 0.8. -* **Print**. `[-p, --print]`. _Optional_. If output file is provided, forces the results to still be printed to stdout. - -### Output -If no output file specified or `-p` option is used, results are printed to STDOUT in [ -$\varepsilon_{orig}$ ␣ -span( $\varepsilon_{orig}$ ) ␣ -$\varepsilon_{filt}$ ␣ -span( $\varepsilon_{filt}$ ) ␣ -$\varepsilon_{sort}$ ␣ -span( $\varepsilon_{sort}$ ) -] format, one line per each line of input file (or a single line for command line input). - -If the output file was specified among the input arguments, the results will be written into that file in JSON format as -a list of dictionaries, one per input line: - -``` -[ - { - "ephemerality_original": FLOAT, - "ephemerality_original_span": INT, - "ephemerality_filtered": FLOAT, - "ephemerality_filtered_span": INT, - "ephemerality_sorted": FLOAT, - "ephemerality_sorted_span": INT - }, - ... -] -``` - -### Example - -Input file `test_input.csv`: -``` -0.0,0.0,0.0,0.2,0.55,0.0,0.15,0.1,0.0,0.0 -0,1,1.,0.0,.0 -``` - -#### Python execution: - -Input 1: - -``` -python ephemerality.py -i tmp/test_input.csv -t 0.8 --output tmp/test_output.json -P -``` - -Output 1: -``` -0.1250000000000001 7 0.5 4 0.625 3 -0.2500000000000001 3 0.5 2 0.5 2 -``` - -`test_output.json` content: -``` -[ - { - "ephemerality_original": 0.1250000000000001, - "ephemerality_original_span": 7, - "ephemerality_filtered": 0.5, - "ephemerality_filtered_span": 4, - "ephemerality_sorted": 0.625, - "ephemerality_sorted_span": 3 - }, - { - "ephemerality_original": 0.2500000000000001, - "ephemerality_original_span": 3, - "ephemerality_filtered": 0.5, - "ephemerality_filtered_span": 2, - "ephemerality_sorted": 0.5, - "ephemerality_sorted_span": 2 - } -] -``` - -Input 2: - -``` -python ephemerality.py 0.0 0.0 0.0 0.2 0.55 0.0 0.15 0.1 0.0 0.0 -t 0.5 -``` - -Output 2: -``` -0.0 5 0.8 1 0.8 1 -``` - -#### Docker execution -``` -docker run -a STDOUT -v [PATH_TO_FOLDER]/tmp/:/tmp/ ephemerality:1.0.0 -i /tmp/test_input.csv -o /tmp/test_output.json -t 0.5 -p -``` - -Output: -``` -0.0 5 0.8 1 0.8 1 -0.19999999999999996 2 0.6 1 0.6 1 -``` - -`test_output.json` content: -``` -[ - { - "ephemerality_original": 0.0, - "ephemerality_original_span": 5, - "ephemerality_filtered": 0.8, - "ephemerality_filtered_span": 1, - "ephemerality_sorted": 0.8, - "ephemerality_sorted_span": 1 - }, - { - "ephemerality_original": 0.19999999999999996, - "ephemerality_original_span": 2, - "ephemerality_filtered": 0.6, - "ephemerality_filtered_span": 1, - "ephemerality_sorted": 0.6, - "ephemerality_sorted_span": 1 - } -] -``` - - -## References -[1] -Gnatyshak, D., Garcia-Gasulla, D., Alvarez-Napagao, S., Arjona, J., & Venturini, T. (2022). Healthy Twitter discussions? Time will tell. arXiv preprint arXiv:2203.11261 diff --git a/ephemerality.egg-info/SOURCES.txt b/ephemerality.egg-info/SOURCES.txt deleted file mode 100644 index 6f2e026..0000000 --- a/ephemerality.egg-info/SOURCES.txt +++ /dev/null @@ -1,17 +0,0 @@ -README.md -setup.py -ephemerality/__init__.py -ephemerality/data_processing.py -ephemerality/ephemerality_computation.py -ephemerality/utils.py -ephemerality.egg-info/PKG-INFO -ephemerality.egg-info/SOURCES.txt -ephemerality.egg-info/dependency_links.txt -ephemerality.egg-info/requires.txt -ephemerality.egg-info/top_level.txt -scripts/ephemerality-api.py -scripts/ephemerality-cmd.py -testing/__init__.py -testing/data_generator.py -testing/test_ephemerality.py -testing/test_utils.py \ No newline at end of file diff --git a/ephemerality.egg-info/dependency_links.txt b/ephemerality.egg-info/dependency_links.txt deleted file mode 100644 index 8b13789..0000000 --- a/ephemerality.egg-info/dependency_links.txt +++ /dev/null @@ -1 +0,0 @@ - diff --git a/ephemerality.egg-info/requires.txt b/ephemerality.egg-info/requires.txt deleted file mode 100644 index 87ce2ac..0000000 --- a/ephemerality.egg-info/requires.txt +++ /dev/null @@ -1,8 +0,0 @@ -numpy==1.24.2 -fastapi==0.95.0 -setuptools==67.6.1 -pydantic==1.10.7 - -[test] -matplotlib==3.7.1 -requests==2.28.2 diff --git a/ephemerality.egg-info/top_level.txt b/ephemerality.egg-info/top_level.txt deleted file mode 100644 index ca2f85f..0000000 --- a/ephemerality.egg-info/top_level.txt +++ /dev/null @@ -1,2 +0,0 @@ -ephemerality -testing diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py index f74e392..16006bd 100644 --- a/ephemerality/__init__.py +++ b/ephemerality/__init__.py @@ -1,5 +1,5 @@ -from ephemerality.ephemerality_computation import compute_ephemerality -from ephemerality.data_processing import process_input, InputData, ProcessedData -from ephemerality.utils import ResultSet +from ephemerality import compute_ephemerality +from ephemerality import ResultSet as EphemeralitySet -__all__ = [compute_ephemerality, ResultSet, process_input, InputData, ProcessedData] + +__all__ = [compute_ephemerality, EphemeralitySet] diff --git a/ephemerality/__main__.py b/ephemerality/__main__.py new file mode 100644 index 0000000..a120b12 --- /dev/null +++ b/ephemerality/__main__.py @@ -0,0 +1,36 @@ +from argparse import ArgumentParser +from ephemerality.scripts import init_cmd_parser, init_api_argparse +from _version import __version__ + + +PROG = "python3 -m ephemerality" + + +def init_parser() -> ArgumentParser: + parser = ArgumentParser( + prog=PROG, + usage="%(prog)s [-h] [-v] {cmd,api} ...", + description="Runs ephemerality computation module in one of the available mode." + ) + parser.add_argument( + "-v", "--version", action="version", + version=f"{parser.prog} version {__version__}" + ) + + subparsers = parser.add_subparsers( + prog=PROG, + help="Use \"cmd\" to run the module once from a command line.\n" + "Use \"api\" to start a REST web service offering ephemerality computation on request." + ) + cmd_parser = subparsers.add_parser("cmd") + api_parser = subparsers.add_parser("api") + + init_cmd_parser(cmd_parser) + init_api_argparse(api_parser) + + return parser + + +parser = init_parser() +args = parser.parse_args() +args.func(args) diff --git a/ephemerality/ephemerality/__init__.py b/ephemerality/ephemerality/__init__.py new file mode 100644 index 0000000..f74e392 --- /dev/null +++ b/ephemerality/ephemerality/__init__.py @@ -0,0 +1,5 @@ +from ephemerality.ephemerality_computation import compute_ephemerality +from ephemerality.data_processing import process_input, InputData, ProcessedData +from ephemerality.utils import ResultSet + +__all__ = [compute_ephemerality, ResultSet, process_input, InputData, ProcessedData] diff --git a/ephemerality/data_processing.py b/ephemerality/ephemerality/data_processing.py similarity index 92% rename from ephemerality/data_processing.py rename to ephemerality/ephemerality/data_processing.py index 3f688cb..51fc824 100644 --- a/ephemerality/data_processing.py +++ b/ephemerality/ephemerality/data_processing.py @@ -22,8 +22,8 @@ class InputData(BaseModel): threshold: float = 0.8 time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format timezone: float = 0. # used only if input_type == 'datetime' | 'd'. Offset in hours from the UTC time. Should be within [-24, +24] range. - range: None | tuple[str, str] = None # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd', - # defaults to (min(input), max(input)) + range: None | tuple[ + str, str] = None # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd', defaults to (min(input), max(input)) granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd'. {'week', 'day', 'hour', '_d', '_h'} reference_name: str = "" @@ -42,7 +42,7 @@ def process_input( input_remote_data: InputData | None = None, input_dict: dict | None = None, input_seq: Sequence[float | int | str] | None = None, - threshold: float=0.8) -> list[ProcessedData]: + threshold: float = 0.8) -> list[ProcessedData]: output = [] if input_folder: @@ -64,6 +64,7 @@ def process_input( return output + def process_folder(path: Path, recursive: bool = True, threshold: float | None = None) -> list[ProcessedData]: output = [] for file in path.iterdir(): @@ -100,8 +101,9 @@ def process_json(path: Path) -> list[ProcessedData]: case_output.name = f"{str(path.absolute())}[{i}]" output.append(case_output) except ValueError: - warnings.warn(f'\"input_type\" is not one of [\"activity\", \"a\", \"timestamps\", \"t\", \"datetime\", \"d\"]!' - f' Ignoring file \"{str(path.absolute())}\"!') + warnings.warn( + f'\"input_type\" is not one of [\"activity\", \"a\", \"timestamps\", \"t\", \"datetime\", \"d\"]!' + f' Ignoring file \"{str(path.absolute())}\"!') return output @@ -122,7 +124,8 @@ def process_formatted_data(input_data: InputData) -> ProcessedData: threshold=input_data.threshold ) elif input_data.input_type == 'datetime' or input_data.input_type == 'd': - timestamps = [datetime.strptime(time_point, input_data.time_format).replace(tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() + timestamps = [datetime.strptime(time_point, input_data.time_format).replace( + tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() for time_point in input_data.input] if input_data.range is not None: ts_range = ( diff --git a/ephemerality/ephemerality_computation.py b/ephemerality/ephemerality/ephemerality_computation.py similarity index 95% rename from ephemerality/ephemerality_computation.py rename to ephemerality/ephemerality/ephemerality_computation.py index 056ad29..429e8d9 100644 --- a/ephemerality/ephemerality_computation.py +++ b/ephemerality/ephemerality/ephemerality_computation.py @@ -50,11 +50,11 @@ def compute_right_core_length(activity_vector: np.array, threshold: float) -> in def compute_middle_core_length(activity_vector: np.array, threshold: float) -> int: lower_threshold = (1. - threshold) / 2 - current_presum = 0 + current_left_sum = 0 start_index = -1 for i, freq in enumerate(activity_vector): - current_presum += freq - if current_presum > lower_threshold and not np.isclose(current_presum, lower_threshold): + current_left_sum += freq + if current_left_sum > lower_threshold and not np.isclose(current_left_sum, lower_threshold): start_index = i break @@ -114,7 +114,7 @@ def compute_ephemerality( length_right_core = compute_right_core_length(activity_vector, threshold) ephemerality_right_core = _compute_ephemerality_from_core(length_right_core, range_length, threshold) else: - length_right_core =None + length_right_core = None ephemerality_right_core = None if 's' in types: diff --git a/ephemerality/utils.py b/ephemerality/ephemerality/utils.py similarity index 100% rename from ephemerality/utils.py rename to ephemerality/ephemerality/utils.py diff --git a/rest/__init__.py b/ephemerality/rest/__init__.py similarity index 88% rename from rest/__init__.py rename to ephemerality/rest/__init__.py index 28e73cc..6829f1c 100644 --- a/rest/__init__.py +++ b/ephemerality/rest/__init__.py @@ -1,7 +1,7 @@ -from ephemerality.data_processing import InputData -from rest.api import set_test_mode, router +from ephemerality import InputData import rest.api_versions as api_versions from rest.api_versions import AbstractRestApi +from rest.api import set_test_mode, router __all__ = [ InputData, diff --git a/rest/api.py b/ephemerality/rest/api.py similarity index 94% rename from rest/api.py rename to ephemerality/rest/api.py index e45852e..755e651 100644 --- a/rest/api.py +++ b/ephemerality/rest/api.py @@ -4,7 +4,7 @@ import sys import time import rest -from ephemerality.data_processing import InputData, process_input +from ephemerality import InputData, process_input from memory_profiler import memory_usage @@ -38,7 +38,7 @@ async def compute_all_ephemeralities( input_data: list[InputData], core_types: Annotated[ str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") - ]="lmrs", + ] = "lmrs", api_version: str | None = None, test_time_reps: Annotated[ int | None, Query(ge=1) @@ -46,8 +46,8 @@ async def compute_all_ephemeralities( test_ram_reps: Annotated[ int | None, Query(ge=1) ] = None, - include_input: bool=True, - explainations: bool=True + include_input: bool = True, + explanations: bool = True ) -> Response: if api_version is None: diff --git a/rest/api_versions/__init__.py b/ephemerality/rest/api_versions/__init__.py similarity index 100% rename from rest/api_versions/__init__.py rename to ephemerality/rest/api_versions/__init__.py diff --git a/rest/api_versions/api11.py b/ephemerality/rest/api_versions/api11.py similarity index 94% rename from rest/api_versions/api11.py rename to ephemerality/rest/api_versions/api11.py index c8c2116..6f4476f 100644 --- a/rest/api_versions/api11.py +++ b/ephemerality/rest/api_versions/api11.py @@ -16,4 +16,4 @@ def get_ephemerality(self, threshold: Annotated[float, Query(gt=0., le=1.)], types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] ) -> ResultSet: - return compute_ephemerality(activity_vector=input_vector, threshold=threshold, types=types) \ No newline at end of file + return compute_ephemerality(activity_vector=input_vector, threshold=threshold, types=types) diff --git a/rest/api_versions/api_template.py b/ephemerality/rest/api_versions/api_template.py similarity index 94% rename from rest/api_versions/api_template.py rename to ephemerality/rest/api_versions/api_template.py index c5b2bfa..e383bf8 100644 --- a/rest/api_versions/api_template.py +++ b/ephemerality/rest/api_versions/api_template.py @@ -16,4 +16,4 @@ def get_ephemerality(self, threshold: Annotated[float, Query(gt=0., le=1.)], types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] ) -> ResultSet: - raise NotImplementedError \ No newline at end of file + raise NotImplementedError diff --git a/ephemerality/rest/runner.py b/ephemerality/rest/runner.py new file mode 100644 index 0000000..886fde2 --- /dev/null +++ b/ephemerality/rest/runner.py @@ -0,0 +1,6 @@ +from fastapi import FastAPI +from rest import router + + +app = FastAPI() +app.include_router(router) diff --git a/ephemerality/scripts/__init__.py b/ephemerality/scripts/__init__.py new file mode 100644 index 0000000..a6c5bc6 --- /dev/null +++ b/ephemerality/scripts/__init__.py @@ -0,0 +1,5 @@ +from scripts.ephemerality_cmd import init_cmd_parser +from scripts.ephemerality_api import init_api_argparse + + +__all__ = [init_cmd_parser, init_api_argparse] diff --git a/ephemerality/scripts/ephemerality_api.py b/ephemerality/scripts/ephemerality_api.py new file mode 100644 index 0000000..f7363b5 --- /dev/null +++ b/ephemerality/scripts/ephemerality_api.py @@ -0,0 +1,34 @@ +from argparse import ArgumentParser, Namespace +from subprocess import call +from rest import set_test_mode + + +def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: + parser.usage = "%(prog)s [-h] [--host HOST] [--port PORT] [--test] ..." + parser.description = "Start a REST web service to compute ephemerality computations on requests." + parser.add_argument( + "--host", action="store", default="127.0.0.1", + help="Bind socket to this host. Defaults to \"127.0.0.1\"." + ) + parser.add_argument( + "--port", action="store", type=int, default=8080, + help="Bind to a socket with this port. Defaults to 8080." + ) + parser.add_argument( + "--test", action="store_true", + help="Run the web service in a mode that allows to process requests to evaluate time and RAM performance of " + "the module (can be computationally expensive!)." + ) + parser.set_defaults( + func=exec_start_service_call + ) + return parser + + +def start_service(host: str = "127.0.0.1", port: int = 8080, test_mode: bool = False) -> None: + set_test_mode(test_mode) + call(['uvicorn', 'rest.runner:app', '--host', host, '--port', str(port)]) + + +def exec_start_service_call(input_args: Namespace) -> None: + start_service(host=input_args.host, port=input_args.port, test_mode=input_args.test) diff --git a/scripts/ephemerality-cmd.py b/ephemerality/scripts/ephemerality_cmd.py similarity index 52% rename from scripts/ephemerality-cmd.py rename to ephemerality/scripts/ephemerality_cmd.py index 9be2e2d..0d3f8ff 100644 --- a/scripts/ephemerality-cmd.py +++ b/ephemerality/scripts/ephemerality_cmd.py @@ -1,45 +1,33 @@ -#!/usr/bin/env python - -import argparse +from argparse import ArgumentParser, Namespace, SUPPRESS import json import sys -import time -from argparse import Namespace from pathlib import Path -from typing import Union import numpy as np -from memory_profiler import memory_usage -from _version import __version__ from ephemerality import compute_ephemerality, process_input, ProcessedData -def init_argparse() -> argparse.ArgumentParser: - parser = argparse.ArgumentParser( - usage="%(prog)s [ACTIVITY_VECTOR] [-h] [-v] [-i INPUT_FILE] [-o OUTPUT_FILE.json] [-t THRESHOLD]...", - description="Calculate ephemerality for a given activity vector or a set of timestamps." - ) - parser.add_argument( - "-v", "--version", action="version", - version=f"{parser.prog} version {__version__}" - ) +def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: + parser.usage = "%(prog)s [activity] [-h] [-i INPUT_FILE] [-r] [-o OUTPUT_FILE.json] [-t THRESHOLD]..." + parser.description = "Calculate ephemerality for a given activity vector or a set of timestamps." parser.add_argument( "-p", "--print", action="store_true", - help="If output file is provided, forces the results to still be printed to stdout." + help="If an output file is specified, forces the results to still be printed to stdout." ) parser.add_argument( "-i", "--input", action="store", help="Path to either a JSON or CSV file with input data, or to the folder with files. If not specified, " - "will read the activity vector from the command line (delimited either by commas or spaces)." + "will read the activity vector from the command line (as numbers delimited by either commas or spaces)." ) parser.add_argument( "-r", "--recursive", action="store_true", - help="Used with a folder --input to specify to also process the files in the full subfolder tree." + help="Used with a folder-type input to specify to also process files in the full subfolder tree. " + "Defaults to False." ) parser.add_argument( "-o", "--output", action="store", - help="Path to the output json file. If not specified, will output ephemerality values to stdout in JSON format." + help="Path to an output JSON file. If not specified, will output ephemerality values to stdout in JSON format." ) parser.add_argument( "-t", "--threshold", action="store", type=float, default=0.8, @@ -47,23 +35,24 @@ def init_argparse() -> argparse.ArgumentParser: ) parser.add_argument( "--test_time_reps", action="store", type=int, default=0, - help="If greater than 0, the script runs in measure performance mode for the specified number of times and" - " output the computation time instead of ephemerality. Defaults to 0." + help=SUPPRESS ) parser.add_argument( "--test_ram_reps", action="store", type=int, default=0, - help="If greater than 0, the script runs in measure performance mode for the specified number of times and" - " output the peak RAM usage instead of ephemerality." + help=SUPPRESS ) parser.add_argument( 'activity', type=float, help='Activity vector (if the input file is not specified)', nargs='*' ) + parser.set_defaults( + func=exec_cmd_compute_call + ) return parser -def run(input_args: Namespace, supress_save_output: bool = False) -> Union[str, None]: +def exec_cmd_compute_call(input_args: Namespace) -> None: if input_args.input: path = Path(input_args.input) if path.is_dir(): @@ -101,46 +90,46 @@ def run(input_args: Namespace, supress_save_output: bool = False) -> Union[str, results[input_case.name] = (compute_ephemerality(activity_vector=input_case.activity, threshold=input_case.threshold).dict()) - if input_args.output and not supress_save_output: + if input_args.output: with open(input_args.output, 'w+') as f: json.dump(results, f, indent=2) if input_args.print: - return json.dumps(results, indent=2) + print(json.dumps(results, indent=2)) else: return None else: - return json.dumps(results, indent=2) - + print(json.dumps(results, indent=2)) -if __name__ == '__main__': - parser = init_argparse() - args = parser.parse_args() - if args.test_time_reps == 0 and args.test_ram_reps == 0: - output = run(args) - if output: - print(output) - else: - output = {} - if args.test_time_reps > 0: - times = [] - for i in range(args.test_time_reps): - start_time = time.time() - run(input_args=args, supress_save_output=True) - times.append(time.time() - start_time) - output["time"] = times - if args.test_ram_reps > 0: - rams = [] - for i in range(args.test_ram_reps): - rams.append(memory_usage( - (run, [], {"input_args": args, "supress_save_output": True}), - max_usage=True - )[0]) - output["RAM"] = rams - if args.output: - with open(args.output, 'w+') as f: - json.dump(output, f, indent=2) - if args.print: - print(json.dumps(output, indent=2)) - else: - print(json.dumps(output, indent=2)) +# if __name__ == '__main__': +# parser = init_cmd_argparse() +# args = parser.parse_args() +# +# if args.test_time_reps == 0 and args.test_ram_reps == 0: +# output = run(input_args=args) +# if output: +# print(output) +# else: +# output = {} +# if args.test_time_reps > 0: +# times = [] +# for i in range(args.test_time_reps): +# start_time = time.time() +# run(input_args=args, supress_save_output=True) +# times.append(time.time() - start_time) +# output["time"] = times +# if args.test_ram_reps > 0: +# rams = [] +# for i in range(args.test_ram_reps): +# rams.append(memory_usage( +# (run, [], {"input_args": args, "supress_save_output": True}), +# max_usage=True +# )[0]) +# output["RAM"] = rams +# if args.output: +# with open(args.output, 'w+') as f: +# json.dump(output, f, indent=2) +# if args.print: +# print(json.dumps(output, indent=2)) +# else: +# print(json.dumps(output, indent=2)) diff --git a/requirements-test.txt b/requirements-test.txt index 5c532c4..933baba 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -1,2 +1,2 @@ -matplotlib==3.7.1 -requests==2.28.2 \ No newline at end of file +requests~=2.28.2 +memory-profiler~=0.61.0 \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index ceafe93..525eaf8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ -numpy==1.24.2 -fastapi==0.95.0 -setuptools==67.6.1 -pydantic==1.10.7 \ No newline at end of file +numpy~=1.24.2 +fastapi~=0.95.1 +setuptools~=67.6.1 +pydantic~=1.10.7 +uvicorn~=0.21.1 diff --git a/scripts/ephemerality-api.py b/scripts/ephemerality-api.py deleted file mode 100644 index 2f74d0f..0000000 --- a/scripts/ephemerality-api.py +++ /dev/null @@ -1,13 +0,0 @@ -#!/usr/bin/env python - -from fastapi import FastAPI -import sys -from rest import set_test_mode, router - - -app = FastAPI() -app.include_router(router) - - -if __name__ == "__main__": - set_test_mode(len(sys.argv) > 1 and sys.argv[1] == 'test') diff --git a/scripts/test_performance.py b/scripts/test_performance.py deleted file mode 100644 index 7c06bcc..0000000 --- a/scripts/test_performance.py +++ /dev/null @@ -1,165 +0,0 @@ -import json - -from _version import __version__ -import argparse -import os -from subprocess import check_output -import shutil -import requests -from pathlib import Path - -from testing import generate_data - - -def init_argparse() -> argparse.ArgumentParser: - parser = argparse.ArgumentParser( - usage="%(prog)s [TYPE(s)] [-h] [-v] [-u URL] [-i INPUT_FOLDER] [-r TESTS_PER_CASE] [-g] [-n MAX_TEST_SIZE] " - "[-m CASES_PER_BATCH] [-s SEED] [-k]...", - description="Run performance tests." - ) - parser.add_argument( - "-v", "--version", action="version", - version=f"{parser.prog} version {__version__}" - ) - parser.add_argument( - "-u", "--url", action="store", default="", - help="URL of REST web service. If not provided, will run tests on command line script instead." - ) - parser.add_argument( - "-i", "--input_folder", action="store", default="./test_data/", - help="Path to the folder with test cases. It will be created if it doesn't exist. " - "Will create a \"performance.json\" file for each subfolder (including the root folder) with input files. " - "Defaults to \"./test_data/\"." - ) - parser.add_argument( - "-r", "--tests_per_case", action="store", type=int, default=20, - help="Number of test repetitions per test case per test. Defaults to 20." - ) - parser.add_argument( - "-g", "--generate", action="store_true", - help="Generate test cases using numpy random number generator. Will generate N batches of inputs. Each one " - "will contain M JSON files with thresholds and input vectors, " - "each vector is of length 10^[batch number from 1 to N]. " - "WARNING: will rewrite the contents of the input folder." - ) - parser.add_argument( - "-n", "--max_size", action="store", type=int, default=6, - help="Maximal size (in power 10) of test size batches. Defaults to 6." - ) - parser.add_argument( - "-m", "--cases_per_batch", action="store", type=int, default=20, - help="Number of test cases in each size batch. Defaults to 20." - ) - parser.add_argument( - "-s", "--seed", action="store", type=int, default=2023, - help="Value of the seed to be used for test case generation. Defaults to 2023." - ) - parser.add_argument( - "-k", "--keep_data", action="store_true", - help="Keep generated test data after tests finish. All GENERATED data will be removed otherwise." - ) - parser.add_argument( - 'types', action="store", default="tcr", - help='test types: \"t\" for computation time, \"r\" for RAM usage. Defaults to \"tr\"' - ) - return parser - - - -if __name__ == '__main__': - parser = init_argparse() - args = parser.parse_args() - - if args.tests_per_case <= 0: - raise ValueError("\"tests_per_case\" value should be positive!") - if args.max_size <= 0: - raise ValueError("\"max_size\" value should be positive!") - if args.cases_per_batch <= 0: - raise ValueError("\"cases_per_batch\" value should be positive!") - - # Data - if args.generate: - generate_data( - max_size=args.max_size, - inputs_per_n=args.cases_per_batch, - seed=args.seed, - save_dir=args.input_folder) - else: - if not os.path.exists(args.input_folder): - raise FileNotFoundError("Input folder does not exist and no data generation has been requested!") - elif not os.path.isdir(args.input_folder): - raise NotADirectoryError("Specified input folder is not a directory.") - - - - # Test - - results = {} - if args.url: - if args.url[-1] != '/': - args.url += '/' - if 't' in args.types: - time_results = {} - for json_file in Path(args.input_folder).rglob("*.json"): - with open(json_file, 'r') as f: - test_case = json.load(f) - case_times = [] - for i in range(args.tests_per_case): - response = requests.post(f"args.url?test_time_reps={1}", json=test_case) - case_times.append(response.json()["time"][0]) - time_results[str(json_file.absolute())] = case_times - results["time"] = time_results - if 'r' in args.types: - ram_results = {} - for json_file in Path(args.input_folder).rglob("*.json"): - with open(json_file, 'r') as f: - test_case = json.load(f) - case_rams = [] - for i in range(args.tests_per_case): - response = requests.post(f"{args.url}?test_ram_reps={1}", json=test_case) - case_rams.append(response.json()["RAM"][0]) - ram_results[str(json_file.absolute())] = case_rams - results["RAM"] = ram_results - else: - if 't' in args.types: - time_results = {} - for json_file in Path(args.input_folder).rglob("*.json"): - case_times = [] - for i in range(args.tests_per_case): - run_results = check_output([ - "python", "ephemerality-cmd.py", - "-i", str(json_file.absolute()), - "--test_time_reps", "1" - ]) - case_times.append(json.load(run_results)["time"][0]) - time_results[str(json_file.absolute())] = case_times - results["time"] = time_results - if 'r' in args.types: - ram_results = {} - for json_file in Path(args.input_folder).rglob("*.json"): - case_rams = [] - for i in range(args.tests_per_case): - run_results = check_output([ - "python", "ephemerality-cmd.py", - "-i", str(json_file.absolute()), - "--test_ram_reps", "1" - ]) - case_rams.append(json.load(run_results)["RAM"][0]) - ram_results[str(json_file.absolute())] = case_rams - results["RAM"] = ram_results - - print(results) - - with open('./test_results.json', 'w+') as f: - json.dump(results, f) - - if args.generate and not args.keep_data: - for filename in os.listdir(args.input_folder): - file_path = os.path.join(args.input_folder, filename) - try: - if os.path.isfile(file_path) or os.path.islink(file_path): - os.unlink(file_path) - elif os.path.isdir(file_path): - shutil.rmtree(file_path) - except Exception as e: - print('Failed to delete %s. Reason: %s' % (file_path, e)) diff --git a/setup.py b/setup.py index 263538a..339184f 100644 --- a/setup.py +++ b/setup.py @@ -20,27 +20,25 @@ def read(file_name): setup( name='ephemerality', version=version, - packages=['ephemerality', 'testing'], + packages=['ephemerality'], url='https://github.com/HPAI-BSC/ephemerality', license='MIT', + license_files=['./LICENSE'], author='HPAI BSC', author_email='dmitry.gnatyshak@bsc.es', - description='Module for computing ephemerality metrics of temporal arrays.', + description='Module for computing ephemerality metrics of temporal activity arrays.', long_description=read('README.md'), - scripts=[ - 'scripts/ephemerality-api.py', - 'scripts/ephemerality-cmd.py' - ], + scripts=[], install_requires=[ - 'numpy==1.24.2', - 'fastapi==0.95.0', - 'setuptools==67.6.1', - 'pydantic==1.10.7' + 'numpy~=1.24.2', + 'fastapi~=0.95.1', + 'setuptools~=67.6.1', + 'pydantic~=1.10.7', + 'uvicorn~=0.21.1' ], extras_require={ - 'test':[ - 'matplotlib==3.7.1', - 'requests==2.28.2' + 'test': [ + 'requests~=2.28.2' ] } ) diff --git a/testing/__init__.py b/testing/__init__.py deleted file mode 100644 index 588b78d..0000000 --- a/testing/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from testing.data_generator import generate_test_case, generate_data - - -__all__ = [generate_test_case, generate_data] diff --git a/testing/data_generator.py b/testing/data_generator.py deleted file mode 100644 index eab53ac..0000000 --- a/testing/data_generator.py +++ /dev/null @@ -1,37 +0,0 @@ -import json -import os - -import numpy as np - - -def generate_test_case(size: int, seed: None | int=None) -> tuple[float, list[float]]: - vector = np.zeros((size,)) - rng = np.random.default_rng(seed) - threshold = rng.uniform(low=0.1, high=0.9, size=None) - vector[0] = rng.normal(scale=10) - for i in range(1, size): - vector[i] = vector[i-1] + rng.normal() - vector -= np.mean(vector) - vector = vector.clip(min=0) - vector /= np.sum(vector) - - return threshold, list(vector) - - -def generate_data(max_size: int=10, inputs_per_n: int=100, seed: int=2023, save_dir: str= "./test_data/") -> None: - if save_dir and save_dir[-1] != '/': - save_dir += '/' - - for n in range(1, max_size): - dir_n = f"{save_dir}{n}" - os.makedirs(dir_n, exist_ok=True) - - for i in range(inputs_per_n): - test_case = generate_test_case(10**n, seed + i) - test_data = [{ - "threshold": test_case[0], - "input_sequence": test_case[1] - }] - - with open(f"{dir_n}/{i}.json", "w") as f: - json.dump(test_data, f) diff --git a/testing/test_ephemerality.py b/testing/test_ephemerality.py deleted file mode 100644 index 57e3b1e..0000000 --- a/testing/test_ephemerality.py +++ /dev/null @@ -1,670 +0,0 @@ -from unittest import TestCase -import numpy as np -from testing.test_utils import EphemeralityTestCase -from ephemerality import compute_ephemerality, ResultSet - - -TEST_CASES = [ - EphemeralityTestCase( - input_sequence=[1.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0.375, - eph_middle_core=0.375, - eph_right_core=0., - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.375, - eph_right_core=0.375, - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[.5, .5], - threshold=0.8, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=2, - len_right_core=2, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[.5, .5], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0.7, .3], - threshold=0.8, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=2, - len_right_core=2, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0.7, .3], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=4, - len_sorted_core=1, - eph_left_core=0.6875, - eph_middle_core=0.6875, - eph_right_core=0., - eph_sorted_core=0.6875 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=4, - len_sorted_core=1, - eph_left_core=1 / 6, - eph_middle_core=1 / 6, - eph_right_core=0., - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=4, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.6875, - eph_right_core=0.6875, - eph_sorted_core=0.6875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=4, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=1 / 6, - eph_right_core=1 / 6, - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1., 0., 1.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=4, - len_middle_core=3, - len_right_core=3, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0.0625, - eph_right_core=0.0625, - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1., 0., 1.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=1 / 6, - eph_right_core=1 / 6, - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 1., 1.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=4, - len_middle_core=4, - len_right_core=4, - len_sorted_core=4, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 1., 1.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=2, - len_right_core=2, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=2, - len_right_core=4, - len_sorted_core=2, - eph_left_core=0.375, - eph_middle_core=0.375, - eph_right_core=0., - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=3, - len_sorted_core=1, - eph_left_core=1 / 6, - eph_middle_core=1 / 6, - eph_right_core=0, - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=10, - len_sorted_core=1, - eph_left_core=0.875, - eph_middle_core=0.875, - eph_right_core=0., - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=10, - len_sorted_core=1, - eph_left_core=2 / 3, - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=5, - len_middle_core=1, - len_right_core=6, - len_sorted_core=1, - eph_left_core=0.375, - eph_middle_core=0.875, - eph_right_core=0.25, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=5, - len_middle_core=1, - len_right_core=6, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=3, - len_middle_core=1, - len_right_core=8, - len_sorted_core=1, - eph_left_core=0.625, - eph_middle_core=0.875, - eph_right_core=0., - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=3, - len_middle_core=1, - len_right_core=8, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=4, - len_middle_core=1, - len_right_core=7, - len_sorted_core=1, - eph_left_core=0.5, - eph_middle_core=0.875, - eph_right_core=0.125, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=4, - len_middle_core=1, - len_right_core=7, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=8, - len_middle_core=1, - len_right_core=3, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.875, - eph_right_core=0.625, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=8, - len_middle_core=1, - len_right_core=3, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=9, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.875, - eph_right_core=0.75, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=9, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=1 / 3, - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=10, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.875, - eph_right_core=0.875, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=10, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=2 / 3, - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], - threshold=0.8, - expected_output=ResultSet( - len_left_core=8, - len_middle_core=8, - len_right_core=8, - len_sorted_core=8, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], - threshold=0.3, - expected_output=ResultSet( - len_left_core=3, - len_middle_core=3, - len_right_core=3, - len_sorted_core=3, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], - threshold=0.8, - expected_output=ResultSet( - len_left_core=7, - len_middle_core=4, - len_right_core=6, - len_sorted_core=3, - eph_left_core=0.125, - eph_middle_core=0.5, - eph_right_core=0.25, - eph_sorted_core=0.625 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], - threshold=0.3, - expected_output=ResultSet( - len_left_core=5, - len_middle_core=1, - len_right_core=6, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=np.eye(1, 10000, k=5000).flatten(), - threshold=0.8, - expected_output=ResultSet( - len_left_core=5001, - len_middle_core=1, - len_right_core=5000, - len_sorted_core=1, - eph_left_core=0.374875, - eph_middle_core=0.999875, - eph_right_core=0.375, - eph_sorted_core=0.999875 - ) - ), - EphemeralityTestCase( - input_sequence=np.eye(1, 10000, k=5000).flatten(), - threshold=0.3, - expected_output=ResultSet( - len_left_core=5001, - len_middle_core=1, - len_right_core=5000, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2999 / 3000, - eph_right_core=0., - eph_sorted_core=2999 / 3000 - ) - ), - EphemeralityTestCase( - input_sequence=np.ones((10000,)), - threshold=0.8, - expected_output=ResultSet( - len_left_core=8000, - len_middle_core=8000, - len_right_core=8000, - len_sorted_core=8000, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=np.ones((10000,)), - threshold=0.3, - expected_output=ResultSet( - len_left_core=3000, - len_middle_core=3000, - len_right_core=3000, - len_sorted_core=3000, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), - threshold=0.8, - expected_output=ResultSet( - len_left_core=10000, - len_middle_core=10000, - len_right_core=10000, - len_sorted_core=4, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0.9995 - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), - threshold=0.3, - expected_output=ResultSet( - len_left_core=2, - len_middle_core=9998, - len_right_core=2, - len_sorted_core=2, - eph_left_core=1499 / 1500, - eph_middle_core=0., - eph_right_core=1499 / 1500, - eph_sorted_core=1499 / 1500 - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), - threshold=0.8, - expected_output=ResultSet( - len_left_core=10001, - len_middle_core=10001, - len_right_core=10001, - len_sorted_core=3, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=39989 / 40004 - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), - threshold=0.3, - expected_output=ResultSet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=29993 / 30003, - eph_middle_core=29993 / 30003, - eph_right_core=29993 / 30003, - eph_sorted_core=29993 / 30003 - ) - ) -] - - -class TestComputeEphemerality(TestCase): - def test_compute_ephemeralities(self): - for i, test_case in enumerate(TEST_CASES): - with self.subTest(): - print(f'\nRunning test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') - - actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, - threshold=test_case.threshold) - - try: - self.assertEquals(test_case.expected_output, actual_output) - except AssertionError as ex: - print(f"\tAssertion error while processing test case {i}: {test_case.input_sequence}, " - f"threshold {test_case.threshold}...") - print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") - raise ex diff --git a/testing/test_utils.py b/testing/test_utils.py deleted file mode 100644 index 42e1a97..0000000 --- a/testing/test_utils.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import Sequence -from dataclasses import dataclass - -from ephemerality import ResultSet - -@dataclass -class EphemeralityTestCase: - input_sequence: Sequence[float] - threshold: float - expected_output: ResultSet From 58e46cc4d3c4b7d832541e7cb85d0430164749a3 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 18 Apr 2023 21:31:01 +0200 Subject: [PATCH 07/11] Fix REST api runner --- dist/ephemerality-1.1.0-py3.10.egg | Bin 0 -> 57736 bytes ephemerality/__init__.py | 4 +- ephemerality/__main__.py | 4 +- _version.py => ephemerality/_version.py | 0 ephemerality/ephemerality/__init__.py | 5 - ephemerality/rest/__init__.py | 8 +- ephemerality/rest/api.py | 102 +++++++++++++----- ephemerality/rest/api_versions/__init__.py | 4 +- ephemerality/rest/api_versions/api11.py | 15 +-- .../rest/api_versions/api_template.py | 2 +- ephemerality/rest/runner.py | 2 +- ephemerality/scripts/__init__.py | 5 +- ephemerality/scripts/ephemerality_api.py | 5 +- ephemerality/scripts/ephemerality_cmd.py | 5 +- ephemerality/src/__init__.py | 5 + .../{ephemerality => src}/data_processing.py | 16 +-- .../ephemerality_computation.py | 5 +- ephemerality/{ephemerality => src}/utils.py | 2 +- setup.py | 7 +- 19 files changed, 124 insertions(+), 72 deletions(-) create mode 100644 dist/ephemerality-1.1.0-py3.10.egg rename _version.py => ephemerality/_version.py (100%) delete mode 100644 ephemerality/ephemerality/__init__.py create mode 100644 ephemerality/src/__init__.py rename ephemerality/{ephemerality => src}/data_processing.py (96%) rename ephemerality/{ephemerality => src}/ephemerality_computation.py (99%) rename ephemerality/{ephemerality => src}/utils.py (100%) diff --git a/dist/ephemerality-1.1.0-py3.10.egg b/dist/ephemerality-1.1.0-py3.10.egg new file mode 100644 index 0000000000000000000000000000000000000000..3907e87876b31d11dba8d9954df7611d680c7f11 GIT binary patch literal 57736 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 Ar2qf` literal 0 HcmV?d00001 diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py index 16006bd..41fecc5 100644 --- a/ephemerality/__init__.py +++ b/ephemerality/__init__.py @@ -1,5 +1,5 @@ -from ephemerality import compute_ephemerality -from ephemerality import ResultSet as EphemeralitySet +from ephemerality.src import ResultSet as EphemeralitySet +from ephemerality.src import compute_ephemerality __all__ = [compute_ephemerality, EphemeralitySet] diff --git a/ephemerality/__main__.py b/ephemerality/__main__.py index a120b12..71792e7 100644 --- a/ephemerality/__main__.py +++ b/ephemerality/__main__.py @@ -1,7 +1,7 @@ from argparse import ArgumentParser -from ephemerality.scripts import init_cmd_parser, init_api_argparse -from _version import __version__ +from ephemerality._version import __version__ +from ephemerality.scripts import init_cmd_parser, init_api_argparse PROG = "python3 -m ephemerality" diff --git a/_version.py b/ephemerality/_version.py similarity index 100% rename from _version.py rename to ephemerality/_version.py diff --git a/ephemerality/ephemerality/__init__.py b/ephemerality/ephemerality/__init__.py deleted file mode 100644 index f74e392..0000000 --- a/ephemerality/ephemerality/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from ephemerality.ephemerality_computation import compute_ephemerality -from ephemerality.data_processing import process_input, InputData, ProcessedData -from ephemerality.utils import ResultSet - -__all__ = [compute_ephemerality, ResultSet, process_input, InputData, ProcessedData] diff --git a/ephemerality/rest/__init__.py b/ephemerality/rest/__init__.py index 6829f1c..24d5ca9 100644 --- a/ephemerality/rest/__init__.py +++ b/ephemerality/rest/__init__.py @@ -1,7 +1,7 @@ -from ephemerality import InputData -import rest.api_versions as api_versions -from rest.api_versions import AbstractRestApi -from rest.api import set_test_mode, router +import ephemerality.rest.api_versions as api_versions +from ephemerality.rest.api_versions import AbstractRestApi +from ephemerality.rest.api import set_test_mode, router +from ephemerality.src import InputData __all__ = [ InputData, diff --git a/ephemerality/rest/api.py b/ephemerality/rest/api.py index 755e651..0c4d6e4 100644 --- a/ephemerality/rest/api.py +++ b/ephemerality/rest/api.py @@ -1,12 +1,12 @@ -from fastapi import APIRouter, status, Query, Response -from fastapi.responses import JSONResponse -from typing import Annotated, Any, Union import sys import time -import rest -from ephemerality import InputData, process_input -from memory_profiler import memory_usage +from typing import Annotated, Any, Union +import ephemerality.rest as rest +from ephemerality.src import InputData, process_input +from fastapi import APIRouter, status, Query, Response +from fastapi.responses import JSONResponse +from memory_profiler import memory_usage TEST_MODE = len(sys.argv) > 1 and sys.argv[1] == 'test' router = APIRouter() @@ -21,8 +21,13 @@ def run_computations(input_data: list[InputData], core_types: str, api: rest.Abs -> Union[list[dict[str, Any] | dict[str, dict[str, Any]]], None]: output = [] for test_case in input_data: - vector, threshold = process_input(input_remote_data=test_case) - case_output = api.get_ephemerality(input_vector=vector, threshold=threshold, types=core_types).dict(exclude_none=True) + case_input = process_input(input_remote_data=test_case)[0] + case_output = api.get_ephemerality( + input_vector=case_input.activity, + threshold=case_input.threshold, + types=core_types + ).dict(exclude_none=True) + if include_input: output.append({ "input": test_case.dict(), @@ -33,26 +38,16 @@ def run_computations(input_data: list[InputData], core_types: str, api: rest.Abs return output -@router.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) -async def compute_all_ephemeralities( +def process_request( input_data: list[InputData], - core_types: Annotated[ - str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") - ] = "lmrs", - api_version: str | None = None, - test_time_reps: Annotated[ - int | None, Query(ge=1) - ] = None, - test_ram_reps: Annotated[ - int | None, Query(ge=1) - ] = None, - include_input: bool = True, - explanations: bool = True + api_version: str, + core_types: str, + test_time_reps: int | None, + test_ram_reps: int | None, + include_input: bool, + explanations: bool ) -> Response: - - if api_version is None: - api = rest.DEFAULT_API - elif api_version not in rest.API_VERSION_DICT: + if api_version not in rest.API_VERSION_DICT: raise ValueError(f'Unrecognized API version: {api_version}!') else: api = rest.API_VERSION_DICT[api_version] @@ -79,3 +74,58 @@ async def compute_all_ephemeralities( else: output = run_computations(input_data=input_data, core_types=core_types, api=api, include_input=include_input) return JSONResponse(content=output) + + +@router.post("/ephemerality/all", status_code=status.HTTP_200_OK) +async def compute_all_ephemeralities_default_version( + input_data: list[InputData], + core_types: Annotated[ + str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") + ] = "lmrs", + test_time_reps: Annotated[ + int | None, Query(ge=1) + ] = None, + test_ram_reps: Annotated[ + int | None, Query(ge=1) + ] = None, + include_input: bool = False, + explanations: bool = False +) -> Response: + default_version = rest.DEFAULT_API.version() + return process_request( + input_data=input_data, + core_types=core_types, + api_version=default_version, + test_time_reps=test_time_reps, + test_ram_reps=test_ram_reps, + include_input=include_input, + explanations=explanations + ) + + +@router.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) +async def compute_all_ephemeralities( + input_data: list[InputData], + api_version: str, + core_types: Annotated[ + str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") + ] = "lmrs", + test_time_reps: Annotated[ + int | None, Query(ge=1) + ] = None, + test_ram_reps: Annotated[ + int | None, Query(ge=1) + ] = None, + include_input: bool = False, + explanations: bool = False +) -> Response: + + return process_request( + input_data=input_data, + core_types=core_types, + api_version=api_version, + test_time_reps=test_time_reps, + test_ram_reps=test_ram_reps, + include_input=include_input, + explanations=explanations + ) diff --git a/ephemerality/rest/api_versions/__init__.py b/ephemerality/rest/api_versions/__init__.py index fd14215..1305962 100644 --- a/ephemerality/rest/api_versions/__init__.py +++ b/ephemerality/rest/api_versions/__init__.py @@ -1,5 +1,5 @@ -from rest.api_versions.api_template import AbstractRestApi -from rest.api_versions.api11 import RestAPI11 +from ephemerality.rest.api_versions.api_template import AbstractRestApi +from ephemerality.rest.api_versions.api11 import RestAPI11 __all__ = [ diff --git a/ephemerality/rest/api_versions/api11.py b/ephemerality/rest/api_versions/api11.py index 6f4476f..a422b40 100644 --- a/ephemerality/rest/api_versions/api11.py +++ b/ephemerality/rest/api_versions/api11.py @@ -2,8 +2,8 @@ from fastapi import Query -from rest.api_versions.api_template import AbstractRestApi -from ephemerality import compute_ephemerality, ResultSet +from ephemerality.rest.api_versions.api_template import AbstractRestApi +from ephemerality.src import compute_ephemerality, ResultSet class RestAPI11(AbstractRestApi): @@ -11,9 +11,10 @@ class RestAPI11(AbstractRestApi): def version() -> str: return "1.1" - def get_ephemerality(self, - input_vector: Sequence[float], - threshold: Annotated[float, Query(gt=0., le=1.)], - types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] - ) -> ResultSet: + @staticmethod + def get_ephemerality( + input_vector: Sequence[float], + threshold: Annotated[float, Query(gt=0., le=1.)], + types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] + ) -> ResultSet: return compute_ephemerality(activity_vector=input_vector, threshold=threshold, types=types) diff --git a/ephemerality/rest/api_versions/api_template.py b/ephemerality/rest/api_versions/api_template.py index e383bf8..6b3ac67 100644 --- a/ephemerality/rest/api_versions/api_template.py +++ b/ephemerality/rest/api_versions/api_template.py @@ -1,7 +1,7 @@ from abc import ABC, abstractmethod from typing import Annotated, Sequence from fastapi import Query -from ephemerality import ResultSet +from ephemerality.src import ResultSet class AbstractRestApi(ABC): diff --git a/ephemerality/rest/runner.py b/ephemerality/rest/runner.py index 886fde2..3687eb1 100644 --- a/ephemerality/rest/runner.py +++ b/ephemerality/rest/runner.py @@ -1,5 +1,5 @@ from fastapi import FastAPI -from rest import router +from ephemerality.rest import router app = FastAPI() diff --git a/ephemerality/scripts/__init__.py b/ephemerality/scripts/__init__.py index a6c5bc6..af29a1f 100644 --- a/ephemerality/scripts/__init__.py +++ b/ephemerality/scripts/__init__.py @@ -1,5 +1,4 @@ -from scripts.ephemerality_cmd import init_cmd_parser -from scripts.ephemerality_api import init_api_argparse - +from ephemerality.scripts.ephemerality_api import init_api_argparse +from ephemerality.scripts.ephemerality_cmd import init_cmd_parser __all__ = [init_cmd_parser, init_api_argparse] diff --git a/ephemerality/scripts/ephemerality_api.py b/ephemerality/scripts/ephemerality_api.py index f7363b5..bf42ae1 100644 --- a/ephemerality/scripts/ephemerality_api.py +++ b/ephemerality/scripts/ephemerality_api.py @@ -1,6 +1,7 @@ from argparse import ArgumentParser, Namespace from subprocess import call -from rest import set_test_mode + +from ephemerality.rest import set_test_mode def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: @@ -27,7 +28,7 @@ def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: def start_service(host: str = "127.0.0.1", port: int = 8080, test_mode: bool = False) -> None: set_test_mode(test_mode) - call(['uvicorn', 'rest.runner:app', '--host', host, '--port', str(port)]) + call(['uvicorn', 'ephemerality.rest.runner:app', '--host', host, '--port', str(port)]) def exec_start_service_call(input_args: Namespace) -> None: diff --git a/ephemerality/scripts/ephemerality_cmd.py b/ephemerality/scripts/ephemerality_cmd.py index 0d3f8ff..007b4e3 100644 --- a/ephemerality/scripts/ephemerality_cmd.py +++ b/ephemerality/scripts/ephemerality_cmd.py @@ -1,11 +1,10 @@ -from argparse import ArgumentParser, Namespace, SUPPRESS import json import sys +from argparse import ArgumentParser, Namespace, SUPPRESS from pathlib import Path import numpy as np - -from ephemerality import compute_ephemerality, process_input, ProcessedData +from ephemerality.src import compute_ephemerality, process_input, ProcessedData def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: diff --git a/ephemerality/src/__init__.py b/ephemerality/src/__init__.py new file mode 100644 index 0000000..8602d6f --- /dev/null +++ b/ephemerality/src/__init__.py @@ -0,0 +1,5 @@ +from ephemerality.src.data_processing import process_input, InputData, ProcessedData +from ephemerality.src.ephemerality_computation import compute_ephemerality +from ephemerality.src.utils import ResultSet + +__all__ = [compute_ephemerality, ResultSet, process_input, InputData, ProcessedData] diff --git a/ephemerality/ephemerality/data_processing.py b/ephemerality/src/data_processing.py similarity index 96% rename from ephemerality/ephemerality/data_processing.py rename to ephemerality/src/data_processing.py index 51fc824..7585132 100644 --- a/ephemerality/ephemerality/data_processing.py +++ b/ephemerality/src/data_processing.py @@ -1,12 +1,12 @@ -import numpy as np -from datetime import datetime, timezone, timedelta -from pathlib import Path -from pydantic import BaseModel -from typing import Sequence import json import warnings from dataclasses import dataclass +from datetime import datetime, timezone, timedelta +from pathlib import Path +from typing import Sequence +import numpy as np +from pydantic import BaseModel SECONDS_WEEK = 604800. SECONDS_DAY = 86400. @@ -79,7 +79,7 @@ def process_file(path: Path, threshold: float | None = None) -> list[ProcessedDa if path.suffix == '.json': return process_json(path) elif path.suffix == '.csv': - return [ProcessedData(name=f"{str(path.absolute())}[{i}]", activity=sequence, threshold=threshold) + return [ProcessedData(name=f"{str(path.resolve())}[{i}]", activity=sequence, threshold=threshold) for i, sequence in enumerate(process_csv(path))] else: return [] @@ -98,12 +98,12 @@ def process_json(path: Path) -> list[ProcessedData]: try: case_output = process_formatted_data(input_case) if not case_output.name: - case_output.name = f"{str(path.absolute())}[{i}]" + case_output.name = f"{str(path.resolve())}[{i}]" output.append(case_output) except ValueError: warnings.warn( f'\"input_type\" is not one of [\"activity\", \"a\", \"timestamps\", \"t\", \"datetime\", \"d\"]!' - f' Ignoring file \"{str(path.absolute())}\"!') + f' Ignoring file \"{str(path.resolve())}\"!') return output diff --git a/ephemerality/ephemerality/ephemerality_computation.py b/ephemerality/src/ephemerality_computation.py similarity index 99% rename from ephemerality/ephemerality/ephemerality_computation.py rename to ephemerality/src/ephemerality_computation.py index 429e8d9..77d4e8a 100644 --- a/ephemerality/ephemerality/ephemerality_computation.py +++ b/ephemerality/src/ephemerality_computation.py @@ -1,6 +1,7 @@ -import numpy as np from typing import Sequence -from ephemerality.utils import ResultSet + +import numpy as np +from ephemerality.src.utils import ResultSet def _check_threshold(threshold: float) -> bool: diff --git a/ephemerality/ephemerality/utils.py b/ephemerality/src/utils.py similarity index 100% rename from ephemerality/ephemerality/utils.py rename to ephemerality/src/utils.py index 67df450..bfdc32f 100644 --- a/ephemerality/ephemerality/utils.py +++ b/ephemerality/src/utils.py @@ -1,5 +1,5 @@ -from pydantic import BaseModel import numpy as np +from pydantic import BaseModel class ResultSet(BaseModel): diff --git a/setup.py b/setup.py index 339184f..9f62fc4 100644 --- a/setup.py +++ b/setup.py @@ -2,12 +2,12 @@ from setuptools import setup import re -VERSION_FILE = "_version.py" +VERSION_FILE = "ephemerality/_version.py" VERSION_REGEX = r"^__version__ = ['\"]([^'\"]*)['\"]" def read(file_name): - return open(os.path.join(os.path.dirname(__file__), file_name)).read() + return open(os.path.join(os.path.dirname(__file__), file_name), 'rt').read() version_lines = open(VERSION_FILE, 'r').read() @@ -38,7 +38,8 @@ def read(file_name): ], extras_require={ 'test': [ - 'requests~=2.28.2' + 'requests~=2.28.2', + 'memory-profiler~=0.61.0' ] } ) From 8033e8fbf460e9dfe317d0ecb81f7eb60027b906 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Wed, 10 May 2023 18:39:46 +0200 Subject: [PATCH 08/11] Finilize performance tests, to be checked. --- .gitignore | 3 +- ephemerality/rest/api.py | 14 ++++- ephemerality/scripts/ephemerality_cmd.py | 78 +++++++++++------------- ephemerality/src/data_processing.py | 8 +-- requirements-test.txt | 3 +- setup.py | 3 +- 6 files changed, 59 insertions(+), 50 deletions(-) diff --git a/.gitignore b/.gitignore index 78190b6..067c035 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ **/venv/ **/tmp_* **/tmp-* -**/testing/ **/test/ **/*.egg-info/ +/testing/test_data/* +/testing/test_output diff --git a/ephemerality/rest/api.py b/ephemerality/rest/api.py index 0c4d6e4..f7e112a 100644 --- a/ephemerality/rest/api.py +++ b/ephemerality/rest/api.py @@ -20,6 +20,7 @@ def set_test_mode(mode: bool) -> None: def run_computations(input_data: list[InputData], core_types: str, api: rest.AbstractRestApi, include_input: bool = False)\ -> Union[list[dict[str, Any] | dict[str, dict[str, Any]]], None]: output = [] + noname_counter = 0 for test_case in input_data: case_input = process_input(input_remote_data=test_case)[0] case_output = api.get_ephemerality( @@ -34,7 +35,16 @@ def run_computations(input_data: list[InputData], core_types: str, api: rest.Abs "output": case_output }) else: - output.append(case_output) + if test_case.reference_name: + input_name = test_case.reference_name + else: + input_name = str(noname_counter) + noname_counter += 1 + + output.append({ + "input": input_name, + "output": case_output + }) return output @@ -67,7 +77,7 @@ def process_request( rams.append(memory_usage( (run_computations, [], {"input_data": input_data, "core_types": core_types, "api": api}), max_usage=True - )[0]) + )) output["RAM"] = rams return JSONResponse(content=output) diff --git a/ephemerality/scripts/ephemerality_cmd.py b/ephemerality/scripts/ephemerality_cmd.py index 007b4e3..8312bde 100644 --- a/ephemerality/scripts/ephemerality_cmd.py +++ b/ephemerality/scripts/ephemerality_cmd.py @@ -1,7 +1,9 @@ import json import sys +import time from argparse import ArgumentParser, Namespace, SUPPRESS from pathlib import Path +from memory_profiler import memory_usage import numpy as np from ephemerality.src import compute_ephemerality, process_input, ProcessedData @@ -28,6 +30,11 @@ def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: "-o", "--output", action="store", help="Path to an output JSON file. If not specified, will output ephemerality values to stdout in JSON format." ) + parser.add_argument( + "--output_indent", action="store", type=int, default=-1, + help="Sets the indentation level of the output (either a JSON file or STDOUT) in terms of number of spaces per " + "level. If negative, will output results as a single line. Defaults to -1." + ) parser.add_argument( "-t", "--threshold", action="store", type=float, default=0.8, help="Threshold value for ephemerality computations in case of CSV input. Defaults to 0.8." @@ -85,50 +92,39 @@ def exec_cmd_compute_call(input_args: Namespace) -> None: sys.exit('No input provided!') results = {} - for input_case in input_cases: - results[input_case.name] = (compute_ephemerality(activity_vector=input_case.activity, - threshold=input_case.threshold).dict()) + if input_args.test_time_reps > 0 or input_args.test_ram_reps > 0: + if input_args.test_time_reps: + for input_case in input_cases: + results["time"] = dict() + times = [] + for i in range(input_args.test_time_reps): + start_time = time.time() + compute_ephemerality(activity_vector=input_case.activity, threshold=input_case.threshold).dict() + times.append(time.time() - start_time) + results["time"][input_case.name] = times + if input_args.test_ram_reps: + for input_case in input_cases: + results["RAM"] = dict() + rams = [] + for i in range(input_args.test_ram_reps): + rams.append(memory_usage( + (compute_ephemerality, [], {"activity_vector": input_case.activity, "threshold": input_case.threshold}), + max_usage=True + )) + results["RAM"][input_case.name] = rams + else: + for input_case in input_cases: + results[input_case.name] = compute_ephemerality(activity_vector=input_case.activity, + threshold=input_case.threshold).dict() + + output_indent = input_args.output_indent if input_args.output_indent >= 0 else None if input_args.output: - with open(input_args.output, 'w+') as f: - json.dump(results, f, indent=2) + with open(input_args.output, 'w') as f: + json.dump(results, f, indent=output_indent, sort_keys=True) if input_args.print: - print(json.dumps(results, indent=2)) + print(json.dumps(results, indent=output_indent, sort_keys=True)) else: return None else: - print(json.dumps(results, indent=2)) - - -# if __name__ == '__main__': -# parser = init_cmd_argparse() -# args = parser.parse_args() -# -# if args.test_time_reps == 0 and args.test_ram_reps == 0: -# output = run(input_args=args) -# if output: -# print(output) -# else: -# output = {} -# if args.test_time_reps > 0: -# times = [] -# for i in range(args.test_time_reps): -# start_time = time.time() -# run(input_args=args, supress_save_output=True) -# times.append(time.time() - start_time) -# output["time"] = times -# if args.test_ram_reps > 0: -# rams = [] -# for i in range(args.test_ram_reps): -# rams.append(memory_usage( -# (run, [], {"input_args": args, "supress_save_output": True}), -# max_usage=True -# )[0]) -# output["RAM"] = rams -# if args.output: -# with open(args.output, 'w+') as f: -# json.dump(output, f, indent=2) -# if args.print: -# print(json.dumps(output, indent=2)) -# else: -# print(json.dumps(output, indent=2)) + print(json.dumps(results, indent=output_indent, sort_keys=True)) diff --git a/ephemerality/src/data_processing.py b/ephemerality/src/data_processing.py index 7585132..5f5eed8 100644 --- a/ephemerality/src/data_processing.py +++ b/ephemerality/src/data_processing.py @@ -17,7 +17,7 @@ class InputData(BaseModel): """ POST request body format """ - input: list[str] + input_sequence: list[str] input_type: str = 'a' # 'activity' | 'a' | 'timestamps' | 't' | 'datetime' | 'd' threshold: float = 0.8 time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format @@ -112,13 +112,13 @@ def process_formatted_data(input_data: InputData) -> ProcessedData: if input_data.input_type == 'activity' or input_data.input_type == 'a': return ProcessedData( name=input_data.reference_name, - activity=np.array(input_data.input, dtype=float), + activity=np.array(input_data.input_sequence, dtype=float), threshold=input_data.threshold ) elif input_data.input_type == 'timestamps' or input_data.input_type == 't': return ProcessedData( name=input_data.reference_name, - activity=timestamps_to_activity(np.array(input_data.input, dtype=float), + activity=timestamps_to_activity(np.array(input_data.input_sequence, dtype=float), input_data.range, input_data.granularity), threshold=input_data.threshold @@ -126,7 +126,7 @@ def process_formatted_data(input_data: InputData) -> ProcessedData: elif input_data.input_type == 'datetime' or input_data.input_type == 'd': timestamps = [datetime.strptime(time_point, input_data.time_format).replace( tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() - for time_point in input_data.input] + for time_point in input_data.input_sequence] if input_data.range is not None: ts_range = ( datetime.strptime(input_data.range[0], input_data.time_format).replace( diff --git a/requirements-test.txt b/requirements-test.txt index 933baba..62a159b 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -1,2 +1,3 @@ requests~=2.28.2 -memory-profiler~=0.61.0 \ No newline at end of file +memory-profiler~=0.61.0 +pytest~=7.3.1 diff --git a/setup.py b/setup.py index 9f62fc4..cd48e69 100644 --- a/setup.py +++ b/setup.py @@ -39,7 +39,8 @@ def read(file_name): extras_require={ 'test': [ 'requests~=2.28.2', - 'memory-profiler~=0.61.0' + 'memory-profiler~=0.61.0', + 'pytest~=7.3.1' ] } ) From 9bebed1c2d04c219d0b674a6adeaee01b22ec635 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Mon, 15 May 2023 12:50:03 +0200 Subject: [PATCH 09/11] Add testing package --- .gitignore | 1 + testing/__init__.py | 4 + testing/run_data_generator.py | 59 +++ testing/run_performance_tests.py | 142 +++++++ testing/run_unit_tests.py | 7 + testing/src/__init__.py | 6 + testing/src/data_generator.py | 94 +++++ testing/src/test_ephemerality.py | 683 +++++++++++++++++++++++++++++++ testing/src/test_performance.py | 73 ++++ testing/src/test_utils.py | 11 + 10 files changed, 1080 insertions(+) create mode 100644 testing/__init__.py create mode 100644 testing/run_data_generator.py create mode 100644 testing/run_performance_tests.py create mode 100644 testing/run_unit_tests.py create mode 100644 testing/src/__init__.py create mode 100644 testing/src/data_generator.py create mode 100644 testing/src/test_ephemerality.py create mode 100644 testing/src/test_performance.py create mode 100644 testing/src/test_utils.py diff --git a/.gitignore b/.gitignore index 067c035..40c3388 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ **/*.egg-info/ /testing/test_data/* /testing/test_output +*.dat \ No newline at end of file diff --git a/testing/__init__.py b/testing/__init__.py new file mode 100644 index 0000000..af2aba1 --- /dev/null +++ b/testing/__init__.py @@ -0,0 +1,4 @@ +from testing.src import generate_data, generate_test_case, clear_data + + +__all__ = [generate_data, generate_test_case, clear_data] diff --git a/testing/run_data_generator.py b/testing/run_data_generator.py new file mode 100644 index 0000000..ca95c5f --- /dev/null +++ b/testing/run_data_generator.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 + +from argparse import ArgumentParser + +from testing import generate_data + + +def init_parser() -> ArgumentParser: + parser = ArgumentParser( + usage="python3 %(prog)s [-o OUTPUT_FOLDER][-g] [-d DATA_TYPE] [--data_range START END] " + "[-n MAX_TEST_SIZE] [-m CASES_PER_BATCH] [-s SEED] ...", + description="Generate data for tests." + ) + parser.add_argument( + "-o", "--output_folder", action="store", default="./test_data/", + help="Path to the folder to store generated test cases. Defaults to \"./test_data/\"." + ) + parser.add_argument( + "-d", "--data_type", action="store", choices=["activity", "a", "timestamps", "t", "datetime", "d"], default="a", + help="Type of the generated data. Defaults to \"a\"." + ) + parser.add_argument( + "--data_range", action="store", type=float, nargs=2, default=None, + help="Value range for timestamps or datetime data types in UNIX timestamp in seconds. " + "Passed as 2 integer numbers. Defaults to (0, 31536000)." + ) + parser.add_argument( + "-n", "--max_size", action="store", type=int, default=6, + help="Maximal size (in power 10) of test size batches. Defaults to 6." + ) + parser.add_argument( + "-m", "--cases_per_batch", action="store", type=int, default=20, + help="Number of test cases in each size batch. Defaults to 20." + ) + parser.add_argument( + "-s", "--seed", action="store", type=int, default=2023, + help="Value of the seed to be used for test case generation. Defaults to 2023." + ) + return parser + + +if __name__ == '__main__': + parser = init_parser() + args = parser.parse_args() + if args.data_range is None: + args.data_range = (0, 31536000) + + if args.max_size <= 0: + raise ValueError("\"max_size\" value should be positive!") + if args.cases_per_batch <= 0: + raise ValueError("\"cases_per_batch\" value should be positive!") + + generate_data( + max_size=args.max_size, + inputs_per_n=args.cases_per_batch, + data_type=args.data_type, + data_range=args.data_range, + seed=args.seed, + save_dir=args.output_folder) diff --git a/testing/run_performance_tests.py b/testing/run_performance_tests.py new file mode 100644 index 0000000..555c6e7 --- /dev/null +++ b/testing/run_performance_tests.py @@ -0,0 +1,142 @@ +#!/usr/bin/env python3 + +import json +from argparse import ArgumentParser +import os +from pathlib import Path +from pprint import pprint + +from testing import generate_data, clear_data +from testing.src import test_performance + + +def init_parser() -> ArgumentParser: + parser = ArgumentParser( + usage="python3 %(prog)s [TYPE(s)] [-h] [-u URL] [-i INPUT_FOLDER] [-o OUTPUT_FILE] [--merge_output] " + "[-r TESTS_PER_CASE] [-g] [-d DATA_TYPE] [--data_range START END] [-n MAX_TEST_SIZE] " + "[-m CASES_PER_BATCH] [-s SEED] [-k] ...", + description="Run performance tests." + ) + parser.add_argument( + "-u", "--url", action="store", default="", + help="URL of REST web service. If not provided, will run tests on command line script instead." + ) + parser.add_argument( + "-i", "--input_folder", action="store", default="./test_data/", + help="Path to the folder with test cases. It will be created if it doesn't exist. " + "Defaults to \"./test_data/\"." + ) + parser.add_argument( + "-o", "--output_file", action="store", default="./test_results.json", + help="Name and path to the JSON file to which the test results will be written. The path will be created if needed. " + "Defaults to \"./test_results.json\"." + ) + parser.add_argument( + "--merge_output", action="store_true", + help="Merges the output of the test with the existing content of the file in top-level array. By default the " + "file is overwritten." + ) + parser.add_argument( + "-r", "--tests_per_case", action="store", type=int, default=20, + help="Number of test repetitions per test case per test. Defaults to 20." + ) + parser.add_argument( + "-g", "--generate", action="store_true", + help="Generate test cases using numpy random number generator. Will generate N batches of inputs. Each one " + "will contain M JSON files with thresholds and input vectors, " + "each vector is of length 10^[batch number from 1 to N]. " + "WARNING: will rewrite the contents of the input folder." + ) + parser.add_argument( + "-d", "--data_type", action="store", choices=["activity", "a", "timestamps", "t", "datetime", "d"], default="a", + help="Type of the generated data. Defaults to \"a\"." + ) + parser.add_argument( + "--data_range", action="store", type=float, nargs=2, default=None, + help="Value range for timestamps or datetime data types in UNIX timestamp in seconds. " + "Passed as 2 integer numbers. Defaults to (0, 31536000)." + ) + parser.add_argument( + "-n", "--max_size", action="store", type=int, default=6, + help="Maximal size (in power 10) of test size batches. Defaults to 6." + ) + parser.add_argument( + "-m", "--cases_per_batch", action="store", type=int, default=20, + help="Number of test cases in each size batch. Defaults to 20." + ) + parser.add_argument( + "-s", "--seed", action="store", type=int, default=2023, + help="Value of the seed to be used for test case generation. Defaults to 2023." + ) + parser.add_argument( + "-k", "--keep_data", action="store_true", + help="Keep generated test data after tests finish. All GENERATED data will be removed otherwise." + ) + parser.add_argument( + 'types', action="store", default="tr", nargs='?', + help='test types: \"t\" for computation time, \"r\" for RAM usage. Defaults to \"tr\"' + ) + return parser + + +if __name__ == '__main__': + parser = init_parser() + args = parser.parse_args() + if args.data_range is None: + args.data_range = (0, 31536000) + + if args.tests_per_case <= 0: + raise ValueError("\"tests_per_case\" value should be positive!") + if args.max_size <= 0: + raise ValueError("\"max_size\" value should be positive!") + if args.cases_per_batch <= 0: + raise ValueError("\"cases_per_batch\" value should be positive!") + + # Data + if args.generate: + generate_data( + max_size=args.max_size, + inputs_per_n=args.cases_per_batch, + data_type=args.data_type, + data_range=args.data_range, + seed=args.seed, + save_dir=args.input_folder) + else: + if not os.path.exists(args.input_folder): + raise FileNotFoundError("Input folder does not exist and no data generation has been requested!") + elif not os.path.isdir(args.input_folder): + raise NotADirectoryError("Specified input folder is not a directory.") + + # Test + results = test_performance( + input_folder=args.input_folder, + url=args.url, + types=args.types, + tests_per_case=args.tests_per_case + ) + pprint(results) + + # Save results + if args.output_file: + output_file = Path(args.output_file).resolve() + if not output_file.exists(): + if not output_file.parent.exists(): + output_file.parent.mkdir(parents=True) + mode = "w" + else: + mode = "w+" if args.merge_output else "w" + + with open(output_file, mode) as f: + if mode == "w": + json.dump(results, f, indent=2, sort_keys=True) + else: + previous_output = json.load(f) + if isinstance(previous_output, list): + previous_output.append(results) + json.dump(previous_output, f) + else: + json.dump([previous_output, results], f) + + # Clear data + if args.generate and not args.keep_data: + clear_data(args.input_folder) diff --git a/testing/run_unit_tests.py b/testing/run_unit_tests.py new file mode 100644 index 0000000..97ea3eb --- /dev/null +++ b/testing/run_unit_tests.py @@ -0,0 +1,7 @@ +#!/usr/bin/env python3 + +from testing.src import test_ephemerality + + +if __name__ == "__main__": + test_ephemerality() diff --git a/testing/src/__init__.py b/testing/src/__init__.py new file mode 100644 index 0000000..98aec0f --- /dev/null +++ b/testing/src/__init__.py @@ -0,0 +1,6 @@ +from testing.src.data_generator import generate_test_case, generate_data, clear_data +from testing.src.test_ephemerality import test_ephemerality +from testing.src.test_performance import test_performance + + +__all__ = [generate_test_case, generate_data, clear_data, test_ephemerality, test_performance] diff --git a/testing/src/data_generator.py b/testing/src/data_generator.py new file mode 100644 index 0000000..3c2cd49 --- /dev/null +++ b/testing/src/data_generator.py @@ -0,0 +1,94 @@ +import json +import os +import numpy as np +from pathlib import Path +import shutil +from datetime import datetime + + +def generate_test_case( + size: int, + data_type: str, + data_range: tuple[float, float] | None = None, + seed: None | int = None, + activity_length: None | int = None +) -> tuple[float, list[float | str]]: + + if activity_length is None: + activity_length = size + activity = np.zeros((activity_length,)) + rng = np.random.default_rng(seed) + threshold = float(rng.uniform(low=0.1, high=0.9, size=None)) + activity[0] = rng.normal(scale=10) + for i in range(1, activity_length): + activity[i] = activity[i - 1] + rng.normal() + activity -= np.mean(activity) + activity = activity.clip(min=0) + + if data_type == "activity" or data_type == "a": + activity /= np.sum(activity) + return threshold, list(activity) + + activity_granule_length = int(np.ceil((data_range[1] - data_range[0]) / activity_length)) + activity = activity.repeat(activity_granule_length)[:(data_range[1] - data_range[0])] + activity /= np.sum(activity) + + timestamps = rng.choice( + a=np.arange(data_range[0], data_range[1]).astype(int), + size=size, + p=activity + ) + timestamps.sort() + + if data_type == "timestamps" or data_type == "t": + return threshold, list(timestamps.astype(str)) + + return threshold, [datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ").replace("000000Z", "000Z") + for ts in timestamps] + + +def generate_data( + max_size: int = 10, + inputs_per_n: int = 100, + data_type: str = "a", + data_range: tuple[float, float] | None = None, + seed: int = 2023, + save_dir: str = "./test_data/" +) -> None: + if save_dir and save_dir[-1] != '/': + save_dir += '/' + + for n in range(1, max_size + 1): + dir_n = Path(f"{save_dir}{n}") + dir_n.mkdir(parents=True, exist_ok=True) + + for i in range(inputs_per_n): + size = 10 ** n + test_case = generate_test_case( + size=size, + data_type=data_type, + data_range=data_range, + seed=seed + i, + activity_length=None if data_type == "activity" or data_type == "a" else int((data_range[1] - data_range[0]) / 1000) + ) + test_data = [{ + "threshold": test_case[0], + "input_sequence": test_case[1], + "input_type": data_type, + "range": [str(data_range[0]), str(data_range[1])], + "reference_name": f"{data_type}_{size}_{i}" + }] + + with open(f"{dir_n}/{i}.json", "w") as f: + json.dump(test_data, f) + + +def clear_data(folder: str) -> None: + for file in Path(folder).iterdir(): + try: + if file.is_file() or file.is_symlink(): + file.unlink() + elif file.is_dir(): + shutil.rmtree(file) + except Exception as ex: + print(f'Failed to delete {file.resolve()}. Reason: {ex}') diff --git a/testing/src/test_ephemerality.py b/testing/src/test_ephemerality.py new file mode 100644 index 0000000..a5b8f21 --- /dev/null +++ b/testing/src/test_ephemerality.py @@ -0,0 +1,683 @@ +from unittest import TestCase, TextTestRunner +import numpy as np +from typing import Sequence +from testing.src.test_utils import EphemeralityTestCase +from ephemerality import compute_ephemerality, EphemeralitySet + + +DEFAULT_TEST_CASES = [ + EphemeralityTestCase( + input_sequence=[1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0.375, + eph_middle_core=0.375, + eph_right_core=0., + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.375, + eph_right_core=0.375, + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.5, .5], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.5, .5], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0.7, .3], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0.7, .3], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=4, + len_sorted_core=1, + eph_left_core=0.6875, + eph_middle_core=0.6875, + eph_right_core=0., + eph_sorted_core=0.6875 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=4, + len_sorted_core=1, + eph_left_core=1 / 6, + eph_middle_core=1 / 6, + eph_right_core=0., + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.6875, + eph_right_core=0.6875, + eph_sorted_core=0.6875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=1 / 6, + eph_right_core=1 / 6, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1., 0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=3, + len_right_core=3, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0.0625, + eph_right_core=0.0625, + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1., 0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=1 / 6, + eph_right_core=1 / 6, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 1., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=4, + len_right_core=4, + len_sorted_core=4, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 1., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=4, + len_sorted_core=2, + eph_left_core=0.375, + eph_middle_core=0.375, + eph_right_core=0., + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=1 / 6, + eph_middle_core=1 / 6, + eph_right_core=0, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=10, + len_sorted_core=1, + eph_left_core=0.875, + eph_middle_core=0.875, + eph_right_core=0., + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=10, + len_sorted_core=1, + eph_left_core=2 / 3, + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0.375, + eph_middle_core=0.875, + eph_right_core=0.25, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=3, + len_middle_core=1, + len_right_core=8, + len_sorted_core=1, + eph_left_core=0.625, + eph_middle_core=0.875, + eph_right_core=0., + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=3, + len_middle_core=1, + len_right_core=8, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=7, + len_sorted_core=1, + eph_left_core=0.5, + eph_middle_core=0.875, + eph_right_core=0.125, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=7, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=8, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.625, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=8, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=9, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.75, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=9, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=1 / 3, + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=10, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.875, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=10, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=2 / 3, + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=8, + len_middle_core=8, + len_right_core=8, + len_sorted_core=8, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=3, + len_middle_core=3, + len_right_core=3, + len_sorted_core=3, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=7, + len_middle_core=4, + len_right_core=6, + len_sorted_core=3, + eph_left_core=0.125, + eph_middle_core=0.5, + eph_right_core=0.25, + eph_sorted_core=0.625 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=np.eye(1, 10000, k=5000).flatten(), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=5001, + len_middle_core=1, + len_right_core=5000, + len_sorted_core=1, + eph_left_core=0.374875, + eph_middle_core=0.999875, + eph_right_core=0.375, + eph_sorted_core=0.999875 + ) + ), + EphemeralityTestCase( + input_sequence=np.eye(1, 10000, k=5000).flatten(), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=5001, + len_middle_core=1, + len_right_core=5000, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2999 / 3000, + eph_right_core=0., + eph_sorted_core=2999 / 3000 + ) + ), + EphemeralityTestCase( + input_sequence=np.ones((10000,)), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=8000, + len_middle_core=8000, + len_right_core=8000, + len_sorted_core=8000, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=np.ones((10000,)), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=3000, + len_middle_core=3000, + len_right_core=3000, + len_sorted_core=3000, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=10000, + len_middle_core=10000, + len_right_core=10000, + len_sorted_core=4, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0.9995 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=9998, + len_right_core=2, + len_sorted_core=2, + eph_left_core=1499 / 1500, + eph_middle_core=0., + eph_right_core=1499 / 1500, + eph_sorted_core=1499 / 1500 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=10001, + len_middle_core=10001, + len_right_core=10001, + len_sorted_core=3, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=39989 / 40004 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=29993 / 30003, + eph_middle_core=29993 / 30003, + eph_right_core=29993 / 30003, + eph_sorted_core=29993 / 30003 + ) + ) +] + + +class TestComputeEphemerality(TestCase): + test_cases: Sequence[EphemeralityTestCase] = DEFAULT_TEST_CASES + + def test_compute_ephemeralities(self): + for i, test_case in enumerate(self.test_cases): + with self.subTest(): + print(f'Running test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') + + actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, + threshold=test_case.threshold) + + try: + self.assertEquals(test_case.expected_output, actual_output) + except AssertionError as ex: + print(f"\tAssertion error while processing test case {i}: {test_case.input_sequence}, " + f"threshold {test_case.threshold}...") + print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") + raise ex + + +def test_ephemerality(test_cases: list[EphemeralityTestCase] | None = None) -> None: + if test_cases is None: + test_cases = DEFAULT_TEST_CASES + test = TestComputeEphemerality('test_compute_ephemeralities') + test.test_cases = test_cases + + runner = TextTestRunner() + runner.run(test) diff --git a/testing/src/test_performance.py b/testing/src/test_performance.py new file mode 100644 index 0000000..b846c23 --- /dev/null +++ b/testing/src/test_performance.py @@ -0,0 +1,73 @@ +import json +import sys +from pathlib import Path +from subprocess import check_output + +import requests + + +def test_performance( + input_folder: str, + url: str | None, + types: str, + tests_per_case: int +) -> dict[str, dict[str, list]]: + results = {} + if url: + if url[-1] != '/': + url += '/' + if 't' in types: + time_results = {} + for json_file in Path(input_folder).rglob("*.json"): + with open(json_file, 'r') as f: + test_case = json.load(f) + case_times = [] + for i in range(tests_per_case): + response = requests.post(f"{url}?test_time_reps={1}", json=test_case) + case_times.append(response.json()["time"][0]) + time_results[str(json_file.resolve())] = case_times + results["time"] = time_results + if 'r' in types: + ram_results = {} + for json_file in Path(input_folder).rglob("*.json"): + with open(json_file, 'r') as f: + test_case = json.load(f) + case_rams = [] + for i in range(tests_per_case): + response = requests.post(f"{url}?test_ram_reps={1}", json=test_case) + case_rams.append(response.json()["RAM"][0]) + ram_results[str(json_file.resolve())] = case_rams + results["RAM"] = ram_results + else: + if 't' in types: + time_results = {} + for json_file in Path(input_folder).rglob("*.json"): + print(json_file.resolve()) + case_times = [] + for i in range(tests_per_case): + run_results = check_output([ + "python3", "-m", "ephemerality", "cmd", + "-i", str(json_file.resolve()), + "--test_time_reps", "1" + ]).decode(sys.stdout.encoding) + run_results = json.loads(run_results)["time"] + case_times.append(run_results[list(run_results.keys())[0]][0]) + time_results[str(json_file.resolve())] = case_times + results["time"] = time_results + if 'r' in types: + ram_results = {} + for json_file in Path(input_folder).rglob("*.json"): + print(json_file.resolve()) + case_rams = [] + for i in range(tests_per_case): + run_results = check_output([ + "python", "ephemerality_cmd.py", + "-i", str(json_file.resolve()), + "--test_ram_reps", "1" + ]).decode(sys.stdout.encoding) + run_results = json.loads(run_results)["RAM"] + case_rams.append(run_results[list(run_results.keys())[0]][0]) + ram_results[str(json_file.resolve())] = case_rams + results["RAM"] = ram_results + + return results diff --git a/testing/src/test_utils.py b/testing/src/test_utils.py new file mode 100644 index 0000000..7433976 --- /dev/null +++ b/testing/src/test_utils.py @@ -0,0 +1,11 @@ +from typing import Sequence +from dataclasses import dataclass + +from ephemerality import EphemeralitySet + + +@dataclass +class EphemeralityTestCase: + input_sequence: Sequence[float] + threshold: float + expected_output: EphemeralitySet From f05feee5a40c25767dbc9be495a8d4647d4a1a24 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Wed, 24 Apr 2024 17:05:25 +0200 Subject: [PATCH 10/11] Add an option to plot activity cores --- .gitignore | 26 +- Dockerfile | 29 +- LICENSE | 40 +- README.md | 454 ++- dist/ephemerality-1.1.0-py3.10.egg | Bin 57736 -> 0 bytes ephemerality/__init__.py | 10 +- ephemerality/__main__.py | 72 +- ephemerality/_version.py | 1 - ephemerality/rest/__init__.py | 29 +- ephemerality/rest/api.py | 233 +- ephemerality/rest/api_versions/__init__.py | 22 +- ephemerality/rest/api_versions/api11.py | 40 +- .../rest/api_versions/api_template.py | 38 +- ephemerality/rest/runner.py | 12 +- ephemerality/scripts/__init__.py | 8 +- ephemerality/scripts/ephemerality_api.py | 70 +- ephemerality/scripts/ephemerality_cmd.py | 260 +- ephemerality/src/__init__.py | 10 +- ephemerality/src/data_processing.py | 386 +-- ephemerality/src/ephemerality_computation.py | 492 ++- ephemerality/src/utils.py | 96 +- poetry.lock | 2744 +++++++++++++++++ pyproject.toml | 17 + requirements-rest.txt | 2 + requirements-test.txt | 3 - requirements.txt | 8 +- setup.py | 86 +- testing/__init__.py | 8 +- testing/run_data_generator.py | 120 +- testing/run_performance_tests.py | 142 - testing/run_unit_tests.py | 14 +- testing/src/__init__.py | 11 +- testing/src/data_generator.py | 187 +- testing/src/test_ephemerality.py | 1366 ++++---- testing/src/test_performance.py | 73 - testing/src/test_utils.py | 22 +- 36 files changed, 4992 insertions(+), 2139 deletions(-) delete mode 100644 dist/ephemerality-1.1.0-py3.10.egg delete mode 100644 ephemerality/_version.py create mode 100644 poetry.lock create mode 100644 pyproject.toml create mode 100644 requirements-rest.txt delete mode 100644 requirements-test.txt delete mode 100644 testing/run_performance_tests.py delete mode 100644 testing/src/test_performance.py diff --git a/.gitignore b/.gitignore index 40c3388..41cf80f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,14 +1,14 @@ -**/tmp/ -**/.pytest_cache/ -*.json -*.pyc -*.idea/ -**/build/ -**/venv/ -**/tmp_* -**/tmp-* -**/test/ -**/*.egg-info/ -/testing/test_data/* -/testing/test_output +**/tmp/ +**/.pytest_cache/ +*.json +*.pyc +*.idea/ +**/build/ +**/venv/ +**/tmp_* +**/tmp-* +**/test/ +**/*.egg-info/ +/testing/test_data/* +/testing/test_output *.dat \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index 7832d7a..55651f7 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,15 +1,14 @@ -FROM python:3.9.15-slim -ARG test=false - -ADD ephemerality /ephemerality -ADD ephemerality.egg-info /ephemerality.egg-info -ADD rest /rest -ADD scripts /scripts -ADD testing /testing -ADD _version.py / -ADD README.md / -ADD setup.py / - -RUN if [ $test = true ] ; then pip install --no-cache-dir --upgrade -e .[test] ; else pip install --no-cache-dir --upgrade .; fi - -ENTRYPOINT ["uvicorn", "scripts.ephemerality-api:app", "--host", "0.0.0.0", "--port", "8080"] +FROM python:3.10-slim + +ADD ephemerality /ephemerality +ADD ephemerality.egg-info /ephemerality.egg-info +ADD rest /rest +ADD scripts /scripts +ADD testing /testing +ADD _version.py / +ADD README.md / +ADD setup.py / + +RUN pip install --no-cache-dir --upgrade -e .[rest] + +ENTRYPOINT ["uvicorn", "scripts.ephemerality-api:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/LICENSE b/LICENSE index 276376f..2e80ea4 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,21 @@ -MIT License - -Copyright (c) 2023 Barcelona Supercomputing Center - Centro Nacional de Supercomputación (BSC-CNS) - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +MIT License + +Copyright (c) 2023 Barcelona Supercomputing Center - Centro Nacional de Supercomputación (BSC-CNS) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index d4fbe6f..12c399e 100644 --- a/README.md +++ b/README.md @@ -1,165 +1,289 @@ -# Ephemerality metric -In [[1]](#1) we formalized the ephemerality metrics used to estimate the healthiness of online discussions. It shows how -'ephemeral' topics are, that is whether the discussions are more or less uniformly active or only revolve around one or -several peaks of activity. - -We defined 3 versions of ephemerality: original, filtered, and sorted. Let us suppose we have a discussion that we can divide in $N$ bins of equal time length and for each bin we can calculate activity in that time period (e.g. number of tweets, watches, visits etc.). Let $t$ denote a normalized vector of frequency corresponding to this discussion, $t_i$ corresponds to normalized activity in during time bin $i$. Let $\alpha\in\left[0, 1\right)$ denote a parameter showing which portion of activity we consider to be the "core" activity. Then we can define ephemerality as a normalized portion of $t$ that contains the remaining $1-\alpha$ activity. We can interpret this definition in three slightly different ways depending on what we consider to be the core activity: - -1. **Original ephemerality**. We calculate core activity as the minimal portion of $t$ starting from the beginning of the vector that contains at least $\alpha$ of the total activity (which is 1 in case of normalized $t$). Then the ephemerality formula can be computed as follows: - -$$ -\varepsilon_{orig}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} t_i \right) \ge \alpha}{N} -$$ - -2. **Filtered ephemerality**. We calculate core activity the minimal *central* portion of $t$ that contains at least $\alpha$ of the total activity. For that we exclude portions of $t$ from the beginning and the end of $t$, so that the sum of each of these portions is as close to $\frac{1-\alpha}{2}$ as possible without reaching it: - -$$ -\varepsilon_{filt}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} t_i - \max_{p\in [1,N]}: \left( \sum_{j=1\dots p} t_j \right) < \frac{1-\alpha}{2} \right) \ge \alpha}{N} -$$ - -3. **Sorted ephemerality**. Finally, we can define the core activity as the minimal number of time bins that cover $\alpha$ portion of the activity. For that we sort $t$ components in descending order (denoted as $\widehat{t}$) and then apply the formula of original ephemerality: - -$$ -\varepsilon_{sort}\left(t_i\right) = 1 - \frac1\alpha \frac{\arg\min_{m\in [1,N]}: \left( \sum_{i=1\dots m} \widehat{t}_i \right) \ge \alpha}{N} -$$ - -## Requirements -The code was tested to work with Python 3.8.6 and Numpy 1.21.5, but is expected to also run on their older versions. - -## How to run the experiments -The code can be run directly via the calculate_ephemerality.py script or via a Docker container built with the provided -Dockerfile. - -### Input -The script/container expect the following input arguments: - -* **Frequency vector file**. `[-i PATH, --input PATH]` _Optional_. Path to a file containing one or several arrays of -numbers in csv format (one array per line), representing temporal frequency vectors. They do not need to be normalized: -if they are not --- they will be normalized automatically. -* **Frequency vector**. _Optional_. If input file is not provided, a frequency vector is expected as a positional -argument (either comma- or space-separated). -* **Output file**. `[-o PATH, --output PATH]` _Optional_. If it is provided, the results will be written into this file -in JSON format. -* **Threshold**. `[-t FLOAT, -threshold FLOAT]` _Optional_. Threshold value for ephemerality computations. Defaults -to 0.8. -* **Print**. `[-p, --print]`. _Optional_. If output file is provided, forces the results to still be printed to stdout. - -### Output -If no output file specified or `-p` option is used, results are printed to STDOUT in [ -$\varepsilon_{orig}$ ␣ -span( $\varepsilon_{orig}$ ) ␣ -$\varepsilon_{filt}$ ␣ -span( $\varepsilon_{filt}$ ) ␣ -$\varepsilon_{sort}$ ␣ -span( $\varepsilon_{sort}$ ) -] format, one line per each line of input file (or a single line for command line input). - -If the output file was specified among the input arguments, the results will be written into that file in JSON format as -a list of dictionaries, one per input line: - -``` -[ - { - "ephemerality_original": FLOAT, - "ephemerality_original_span": INT, - "ephemerality_filtered": FLOAT, - "ephemerality_filtered_span": INT, - "ephemerality_sorted": FLOAT, - "ephemerality_sorted_span": INT - }, - ... -] -``` - -### Example - -Input file `test_input.csv`: -``` -0.0,0.0,0.0,0.2,0.55,0.0,0.15,0.1,0.0,0.0 -0,1,1.,0.0,.0 -``` - -#### Python execution: - -Input 1: - -``` -python ephemerality.py -i tmp/test_input.csv -t 0.8 --output tmp/test_output.json -P -``` - -Output 1: -``` -0.1250000000000001 7 0.5 4 0.625 3 -0.2500000000000001 3 0.5 2 0.5 2 -``` - -`test_output.json` content: -``` -[ - { - "ephemerality_original": 0.1250000000000001, - "ephemerality_original_span": 7, - "ephemerality_filtered": 0.5, - "ephemerality_filtered_span": 4, - "ephemerality_sorted": 0.625, - "ephemerality_sorted_span": 3 - }, - { - "ephemerality_original": 0.2500000000000001, - "ephemerality_original_span": 3, - "ephemerality_filtered": 0.5, - "ephemerality_filtered_span": 2, - "ephemerality_sorted": 0.5, - "ephemerality_sorted_span": 2 - } -] -``` - -Input 2: - -``` -python ephemerality.py 0.0 0.0 0.0 0.2 0.55 0.0 0.15 0.1 0.0 0.0 -t 0.5 -``` - -Output 2: -``` -0.0 5 0.8 1 0.8 1 -``` - -#### Docker execution -``` -docker run -a STDOUT -v [PATH_TO_FOLDER]/tmp/:/tmp/ ephemerality:1.0.0 -i /tmp/test_input.csv -o /tmp/test_output.json -t 0.5 -p -``` - -Output: -``` -0.0 5 0.8 1 0.8 1 -0.19999999999999996 2 0.6 1 0.6 1 -``` - -`test_output.json` content: -``` -[ - { - "ephemerality_original": 0.0, - "ephemerality_original_span": 5, - "ephemerality_filtered": 0.8, - "ephemerality_filtered_span": 1, - "ephemerality_sorted": 0.8, - "ephemerality_sorted_span": 1 - }, - { - "ephemerality_original": 0.19999999999999996, - "ephemerality_original_span": 2, - "ephemerality_filtered": 0.6, - "ephemerality_filtered_span": 1, - "ephemerality_sorted": 0.6, - "ephemerality_sorted_span": 1 - } -] -``` - - -## References -[1] -Gnatyshak, D., Garcia-Gasulla, D., Alvarez-Napagao, S., Arjona, J., & Venturini, T. (2022). Healthy Twitter discussions? Time will tell. arXiv preprint arXiv:2203.11261 +# Ephemerality metric +Ephemerality metrics are used to estimate the healthiness of various (online) activities, e.g. online discussions. +It shows how 'ephemeral' these activities are, that is whether they are more or less uniform +over the period of interest or are only clustered around one or several short time periods. + +Ephemerality formula is defined as follows: + +$$ +\varepsilon=\left(1 - \frac1\alpha \cdot \frac{core\ length}{period\ length}\right)^+ +$$ + +Essentially, **ephemerality** is a portion of the time period occupied by non‑core activity. The core activity can be +defined in different ways and is parametrized by $\alpha$ — the minimal percentage of total activity it needs to +contain. + +We defined 4 versions of computing these core periods: + +1. **Left $\alpha$-core**. Continuous time span from **the beginning of the period** to the point when $\alpha$% of +total activity volume is contained within. Measures how fast activity becomes negligible after the start of the period. +Best suited for the types of activity with well-defined start time, e.g. reactions to posts, videos, news, etc. + +2. **Right $\alpha$-core**. Continuous time span from **the end of the period** to the point when $\alpha$% of total +activity volume is contained within. Measures how far in the past the meaningful past of activity spans. Best suited for +when you want to analyze activity within a specific time frame (for instance, up until the current date). + +3. **Middle $\alpha$-core**. Continuous time span from **in the middle of the period** that contains $\alpha$% of total +activity volume. Computed by cutting out at most (but as close to) $\frac{1-\alpha}2$% of activity volume from the +beginning and the end of the period. Best suited for activities with no identifiable start and end times within the +period of interest, e.g. discussions of certain topics onj social media. + +4. **Sorted $\alpha$-core**. **Minimal number of time bins** that together contain $\alpha$% of total activity volume +(left $\alpha$‑core for activity vectors sorted in descending order). Measures what portion of time is occupied by the +most prominent activity. Works well in combination with other cores to check whether all of the activity was centered +around one or more short periods of time. + +## Requirements +The code was tested to work with Python 3.10 and Numpy 1.24.2, but is expected to also run on their older versions. +FastAPI 0.110.0 and uvicorn 0.21.1 are also needed to run the ephemerality computation web-service. + +## How to run the experiments +The code can be run directly as a module `python3 -m ephemerality [args]`. There are two modes provided: a single +command line-based computation and a RESTful service. In case of the latter, there is an option to use a Docker +container, either from Docker Hub (`hpaibsc/ephemerality:latest`) or built with the provided Dockerfile. + +To run the module as a single command line computation use `cmd` argument: + +```shell +python3 -m ephemerality cmd ... +``` + +To start a RESTful service use `api` argument: + +```shell +python3 -m ephemerality api ... +``` + +Finally, it is possible to just import the ephemerality computation function from the module: + +```Python +from ephemerality import compute_ephemerality + +activity = [0., 0., 0., .2, .55, 0., .15, .1, 0., 0.] +threshold = 0.8 +compute_ephemerality(activity, threshold) +``` + +Output: +``` +EphemeralitySet( + eph_left_core=0.1250000000000001, + eph_middle_core=0.5, + eph_right_core=0.2500000000000001, + eph_sorted_core=0.625, + len_left_core=7, + len_middle_core=4, + len_right_core=6, + len_sorted_core=3) +``` + +### Input +The script/container expect the following input arguments: + +* **Frequency vector file**. `[-i PATH, --input PATH]` _Optional_. Path to a file containing one or several arrays of +numbers in csv format (one array per line), representing temporal frequency vectors. They do not need to be normalized: +if they are not --- they will be normalized automatically. +* **Frequency vector**. _Optional_. If input file is not provided, a frequency vector is expected as a positional +argument (either comma- or space-separated). +* **Output file**. `[-o PATH, --output PATH]` _Optional_. If it is provided, the results will be written into this file +in JSON format. +* **Threshold**. `[-t FLOAT, -threshold FLOAT]` _Optional_. Threshold value for ephemerality computations. Defaults +to 0.8. +* **Print**. `[-p, --print]`. _Optional_. If output file is provided, forces the results to still be printed to stdout. + +### Output +If no output file specified or `-p` option is used, results are printed to STDOUT in [ +$\varepsilon_{orig}$ ␣ +span( $\varepsilon_{orig}$ ) ␣ +$\varepsilon_{filt}$ ␣ +span( $\varepsilon_{filt}$ ) ␣ +$\varepsilon_{sort}$ ␣ +span( $\varepsilon_{sort}$ ) +] format, one line per each line of input file (or a single line for command line input). + +If the output file was specified among the input arguments, the results will be written into that file in JSON format as +a list of dictionaries, one per input line: + +``` +[ + { + "ephemerality_original": FLOAT, + "ephemerality_original_span": INT, + "ephemerality_filtered": FLOAT, + "ephemerality_filtered_span": INT, + "ephemerality_sorted": FLOAT, + "ephemerality_sorted_span": INT + }, + ... +] +``` + +[//]: # (### Example) + +[//]: # () +[//]: # (Input file `test_input.csv`:) + +[//]: # (```) + +[//]: # (0.0,0.0,0.0,0.2,0.55,0.0,0.15,0.1,0.0,0.0) + +[//]: # (0,1,1.,0.0,.0) + +[//]: # (```) + +[//]: # () +[//]: # (#### Python execution:) + +[//]: # () +[//]: # (Input 1:) + +[//]: # () +[//]: # (```) + +[//]: # (python ephemerality.py -i tmp/test_input.csv -t 0.8 --output tmp/test_output.json -P) + +[//]: # (```) + +[//]: # () +[//]: # (Output 1:) + +[//]: # (```) + +[//]: # (0.1250000000000001 7 0.5 4 0.625 3) + +[//]: # (0.2500000000000001 3 0.5 2 0.5 2) + +[//]: # (```) + +[//]: # () +[//]: # (`test_output.json` content:) + +[//]: # (```) + +[//]: # ([) + +[//]: # ( {) + +[//]: # ( "ephemerality_original": 0.1250000000000001,) + +[//]: # ( "ephemerality_original_span": 7,) + +[//]: # ( "ephemerality_filtered": 0.5,) + +[//]: # ( "ephemerality_filtered_span": 4,) + +[//]: # ( "ephemerality_sorted": 0.625,) + +[//]: # ( "ephemerality_sorted_span": 3) + +[//]: # ( },) + +[//]: # ( {) + +[//]: # ( "ephemerality_original": 0.2500000000000001,) + +[//]: # ( "ephemerality_original_span": 3,) + +[//]: # ( "ephemerality_filtered": 0.5,) + +[//]: # ( "ephemerality_filtered_span": 2,) + +[//]: # ( "ephemerality_sorted": 0.5,) + +[//]: # ( "ephemerality_sorted_span": 2) + +[//]: # ( }) + +[//]: # (]) + +[//]: # (```) + +[//]: # () +[//]: # (Input 2:) + +[//]: # () +[//]: # (```) + +[//]: # (python ephemerality.py 0.0 0.0 0.0 0.2 0.55 0.0 0.15 0.1 0.0 0.0 -t 0.5) + +[//]: # (```) + +[//]: # () +[//]: # (Output 2:) + +[//]: # (```) + +[//]: # (0.0 5 0.8 1 0.8 1) + +[//]: # (```) + +[//]: # () +[//]: # (#### Docker execution) + +[//]: # (```) + +[//]: # (docker run -a STDOUT -v [PATH_TO_FOLDER]/tmp/:/tmp/ ephemerality:1.0.0 -i /tmp/test_input.csv -o /tmp/test_output.json -t 0.5 -p ) + +[//]: # (```) + +[//]: # () +[//]: # (Output:) + +[//]: # (```) + +[//]: # (0.0 5 0.8 1 0.8 1) + +[//]: # (0.19999999999999996 2 0.6 1 0.6 1) + +[//]: # (```) + +[//]: # () +[//]: # (`test_output.json` content:) + +[//]: # (```) + +[//]: # ([) + +[//]: # ( {) + +[//]: # ( "ephemerality_original": 0.0,) + +[//]: # ( "ephemerality_original_span": 5,) + +[//]: # ( "ephemerality_filtered": 0.8,) + +[//]: # ( "ephemerality_filtered_span": 1,) + +[//]: # ( "ephemerality_sorted": 0.8,) + +[//]: # ( "ephemerality_sorted_span": 1) + +[//]: # ( },) + +[//]: # ( {) + +[//]: # ( "ephemerality_original": 0.19999999999999996,) + +[//]: # ( "ephemerality_original_span": 2,) + +[//]: # ( "ephemerality_filtered": 0.6,) + +[//]: # ( "ephemerality_filtered_span": 1,) + +[//]: # ( "ephemerality_sorted": 0.6,) + +[//]: # ( "ephemerality_sorted_span": 1) + +[//]: # ( }) + +[//]: # (]) + +[//]: # (```) + +[//]: # () +[//]: # () +[//]: # (## References) + +[//]: # ([1]) + +[//]: # (Gnatyshak, D., Garcia-Gasulla, D., Alvarez-Napagao, S., Arjona, J., & Venturini, T. (2022). Healthy Twitter discussions? Time will tell. arXiv preprint arXiv:2203.11261) diff --git a/dist/ephemerality-1.1.0-py3.10.egg b/dist/ephemerality-1.1.0-py3.10.egg deleted file mode 100644 index 3907e87876b31d11dba8d9954df7611d680c7f11..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 57736 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 Ar2qf` diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py index 41fecc5..7d4c8c0 100644 --- a/ephemerality/__init__.py +++ b/ephemerality/__init__.py @@ -1,5 +1,5 @@ -from ephemerality.src import ResultSet as EphemeralitySet -from ephemerality.src import compute_ephemerality - - -__all__ = [compute_ephemerality, EphemeralitySet] +from .src import EphemeralitySet +from .src import compute_ephemerality + + +__all__ = ['compute_ephemerality', 'EphemeralitySet'] diff --git a/ephemerality/__main__.py b/ephemerality/__main__.py index 71792e7..54093c6 100644 --- a/ephemerality/__main__.py +++ b/ephemerality/__main__.py @@ -1,36 +1,36 @@ -from argparse import ArgumentParser - -from ephemerality._version import __version__ -from ephemerality.scripts import init_cmd_parser, init_api_argparse - -PROG = "python3 -m ephemerality" - - -def init_parser() -> ArgumentParser: - parser = ArgumentParser( - prog=PROG, - usage="%(prog)s [-h] [-v] {cmd,api} ...", - description="Runs ephemerality computation module in one of the available mode." - ) - parser.add_argument( - "-v", "--version", action="version", - version=f"{parser.prog} version {__version__}" - ) - - subparsers = parser.add_subparsers( - prog=PROG, - help="Use \"cmd\" to run the module once from a command line.\n" - "Use \"api\" to start a REST web service offering ephemerality computation on request." - ) - cmd_parser = subparsers.add_parser("cmd") - api_parser = subparsers.add_parser("api") - - init_cmd_parser(cmd_parser) - init_api_argparse(api_parser) - - return parser - - -parser = init_parser() -args = parser.parse_args() -args.func(args) +from argparse import ArgumentParser + +from ephemerality._version import __version__ +from ephemerality.scripts import init_cmd_parser, init_api_argparse + +PROG = "python3 -m ephemerality" + + +def init_parser() -> ArgumentParser: + parser = ArgumentParser( + prog=PROG, + usage="%(prog)s [-h] [-v] {cmd,api} ...", + description="Runs ephemerality computation module in one of the available mode." + ) + parser.add_argument( + "-v", "--version", action="version", + version=f"{parser.prog} version {__version__}" + ) + + subparsers = parser.add_subparsers( + prog=PROG, + help="Use \"cmd\" to run the module once from a command line.\n" + "Use \"api\" to start a REST web service offering ephemerality computation on request." + ) + cmd_parser = subparsers.add_parser("cmd") + api_parser = subparsers.add_parser("api") + + init_cmd_parser(cmd_parser) + init_api_argparse(api_parser) + + return parser + + +parser = init_parser() +args = parser.parse_args() +args.func(args) diff --git a/ephemerality/_version.py b/ephemerality/_version.py deleted file mode 100644 index 6849410..0000000 --- a/ephemerality/_version.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = "1.1.0" diff --git a/ephemerality/rest/__init__.py b/ephemerality/rest/__init__.py index 24d5ca9..eeb424f 100644 --- a/ephemerality/rest/__init__.py +++ b/ephemerality/rest/__init__.py @@ -1,15 +1,14 @@ -import ephemerality.rest.api_versions as api_versions -from ephemerality.rest.api_versions import AbstractRestApi -from ephemerality.rest.api import set_test_mode, router -from ephemerality.src import InputData - -__all__ = [ - InputData, - set_test_mode, - router, - AbstractRestApi -] - - -API_VERSION_DICT: dict[str, AbstractRestApi] = {api.version(): api for api in api_versions.__all__ if api.version()} -DEFAULT_API: AbstractRestApi = API_VERSION_DICT[max(API_VERSION_DICT.keys())] +import ephemerality.rest.api_versions as api_versions +from ephemerality.rest.api_versions import AbstractRestApi +from ephemerality.rest.api import router +from ephemerality.src import InputData + +__all__ = [ + 'InputData', + 'router', + 'AbstractRestApi' +] + + +API_VERSION_DICT: dict[str, AbstractRestApi] = {api.version(): api for api in api_versions.__all__ if api.version()} +DEFAULT_API: AbstractRestApi = API_VERSION_DICT[max(API_VERSION_DICT.keys())] diff --git a/ephemerality/rest/api.py b/ephemerality/rest/api.py index f7e112a..cc9fe61 100644 --- a/ephemerality/rest/api.py +++ b/ephemerality/rest/api.py @@ -1,141 +1,92 @@ -import sys -import time -from typing import Annotated, Any, Union - -import ephemerality.rest as rest -from ephemerality.src import InputData, process_input -from fastapi import APIRouter, status, Query, Response -from fastapi.responses import JSONResponse -from memory_profiler import memory_usage - -TEST_MODE = len(sys.argv) > 1 and sys.argv[1] == 'test' -router = APIRouter() - - -def set_test_mode(mode: bool) -> None: - global TEST_MODE - TEST_MODE = mode - - -def run_computations(input_data: list[InputData], core_types: str, api: rest.AbstractRestApi, include_input: bool = False)\ - -> Union[list[dict[str, Any] | dict[str, dict[str, Any]]], None]: - output = [] - noname_counter = 0 - for test_case in input_data: - case_input = process_input(input_remote_data=test_case)[0] - case_output = api.get_ephemerality( - input_vector=case_input.activity, - threshold=case_input.threshold, - types=core_types - ).dict(exclude_none=True) - - if include_input: - output.append({ - "input": test_case.dict(), - "output": case_output - }) - else: - if test_case.reference_name: - input_name = test_case.reference_name - else: - input_name = str(noname_counter) - noname_counter += 1 - - output.append({ - "input": input_name, - "output": case_output - }) - return output - - -def process_request( - input_data: list[InputData], - api_version: str, - core_types: str, - test_time_reps: int | None, - test_ram_reps: int | None, - include_input: bool, - explanations: bool -) -> Response: - if api_version not in rest.API_VERSION_DICT: - raise ValueError(f'Unrecognized API version: {api_version}!') - else: - api = rest.API_VERSION_DICT[api_version] - - if TEST_MODE and (test_time_reps or test_ram_reps): - output = {} - if test_time_reps: - times = [] - for i in range(test_time_reps): - start_time = time.time() - run_computations(input_data=input_data, core_types=core_types, api=api) - times.append(time.time() - start_time) - output["time"] = times - if test_ram_reps: - rams = [] - for i in range(test_ram_reps): - rams.append(memory_usage( - (run_computations, [], {"input_data": input_data, "core_types": core_types, "api": api}), - max_usage=True - )) - output["RAM"] = rams - - return JSONResponse(content=output) - else: - output = run_computations(input_data=input_data, core_types=core_types, api=api, include_input=include_input) - return JSONResponse(content=output) - - -@router.post("/ephemerality/all", status_code=status.HTTP_200_OK) -async def compute_all_ephemeralities_default_version( - input_data: list[InputData], - core_types: Annotated[ - str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") - ] = "lmrs", - test_time_reps: Annotated[ - int | None, Query(ge=1) - ] = None, - test_ram_reps: Annotated[ - int | None, Query(ge=1) - ] = None, - include_input: bool = False, - explanations: bool = False -) -> Response: - default_version = rest.DEFAULT_API.version() - return process_request( - input_data=input_data, - core_types=core_types, - api_version=default_version, - test_time_reps=test_time_reps, - test_ram_reps=test_ram_reps, - include_input=include_input, - explanations=explanations - ) - - -@router.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) -async def compute_all_ephemeralities( - input_data: list[InputData], - api_version: str, - core_types: Annotated[ - str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") - ] = "lmrs", - test_time_reps: Annotated[ - int | None, Query(ge=1) - ] = None, - test_ram_reps: Annotated[ - int | None, Query(ge=1) - ] = None, - include_input: bool = False, - explanations: bool = False -) -> Response: - - return process_request( - input_data=input_data, - core_types=core_types, - api_version=api_version, - test_time_reps=test_time_reps, - test_ram_reps=test_ram_reps, - include_input=include_input, - explanations=explanations - ) +from typing import Annotated, Any, Union + +import ephemerality.rest as rest +from ephemerality.src import InputData, process_input +from fastapi import APIRouter, status, Query, Response +from fastapi.responses import JSONResponse + +router = APIRouter() + + +def run_computations( + input_data: list[InputData], + core_types: str, + api: rest.AbstractRestApi, + include_input: bool = False) -> Union[list[dict[str, Any] | dict[str, dict[str, Any]]], None]: + output = [] + noname_counter = 0 + for test_case in input_data: + case_input = process_input(input_remote_data=test_case)[0] + case_output = api.get_ephemerality( + input_vector=case_input.activity, + threshold=case_input.threshold, + types=core_types + ).dict(exclude_none=True) + + if include_input: + output.append({ + "input": test_case.dict(), + "output": case_output + }) + else: + if test_case.reference_name: + input_name = test_case.reference_name + else: + input_name = str(noname_counter) + noname_counter += 1 + + output.append({ + "input": input_name, + "output": case_output + }) + return output + + +def process_request( + input_data: list[InputData], + api_version: str, + core_types: str, + include_input: bool +) -> Response: + if api_version not in rest.API_VERSION_DICT: + raise ValueError(f'Unrecognized API version: {api_version}!') + else: + api = rest.API_VERSION_DICT[api_version] + + output = run_computations(input_data=input_data, core_types=core_types, api=api, include_input=include_input) + return JSONResponse(content=output) + + +@router.post("/ephemerality/all", status_code=status.HTTP_200_OK) +async def compute_all_ephemeralities_default_version( + input_data: list[InputData], + core_types: Annotated[ + str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") + ] = "lmrs", + include_input: bool = False +) -> Response: + default_version = rest.DEFAULT_API.version() + return process_request( + input_data=input_data, + core_types=core_types, + api_version=default_version, + include_input=include_input + ) + + +@router.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) +async def compute_all_ephemeralities( + input_data: list[InputData], + api_version: str, + core_types: Annotated[ + str, Query(min_length=1, max_length=4, regex="^[lmrs]+$") + ] = "lmrs", + include_input: bool = False +) -> Response: + + return process_request( + input_data=input_data, + core_types=core_types, + api_version=api_version, + include_input=include_input, + ) diff --git a/ephemerality/rest/api_versions/__init__.py b/ephemerality/rest/api_versions/__init__.py index 1305962..22e57f2 100644 --- a/ephemerality/rest/api_versions/__init__.py +++ b/ephemerality/rest/api_versions/__init__.py @@ -1,11 +1,11 @@ -from ephemerality.rest.api_versions.api_template import AbstractRestApi -from ephemerality.rest.api_versions.api11 import RestAPI11 - - -__all__ = [ - AbstractRestApi, - RestAPI11 -] - - - +from ephemerality.rest.api_versions.api_template import AbstractRestApi +from ephemerality.rest.api_versions.api11 import RestAPI11 + + +__all__ = [ + 'AbstractRestApi', + 'RestAPI11' +] + + + diff --git a/ephemerality/rest/api_versions/api11.py b/ephemerality/rest/api_versions/api11.py index a422b40..f7785d6 100644 --- a/ephemerality/rest/api_versions/api11.py +++ b/ephemerality/rest/api_versions/api11.py @@ -1,20 +1,20 @@ -from typing import Sequence, Annotated - -from fastapi import Query - -from ephemerality.rest.api_versions.api_template import AbstractRestApi -from ephemerality.src import compute_ephemerality, ResultSet - - -class RestAPI11(AbstractRestApi): - @staticmethod - def version() -> str: - return "1.1" - - @staticmethod - def get_ephemerality( - input_vector: Sequence[float], - threshold: Annotated[float, Query(gt=0., le=1.)], - types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] - ) -> ResultSet: - return compute_ephemerality(activity_vector=input_vector, threshold=threshold, types=types) +from typing import Sequence, Annotated + +from fastapi import Query + +from ephemerality.rest.api_versions.api_template import AbstractRestApi +from ephemerality.src import compute_ephemerality, EphemeralitySet + + +class RestAPI11(AbstractRestApi): + @staticmethod + def version() -> str: + return "1.1" + + @staticmethod + def get_ephemerality( + input_vector: Sequence[float], + threshold: Annotated[float, Query(gt=0., le=1.)], + types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] + ) -> EphemeralitySet: + return compute_ephemerality(activity_vector=input_vector, threshold=threshold, types=types) diff --git a/ephemerality/rest/api_versions/api_template.py b/ephemerality/rest/api_versions/api_template.py index 6b3ac67..40f345e 100644 --- a/ephemerality/rest/api_versions/api_template.py +++ b/ephemerality/rest/api_versions/api_template.py @@ -1,19 +1,19 @@ -from abc import ABC, abstractmethod -from typing import Annotated, Sequence -from fastapi import Query -from ephemerality.src import ResultSet - - -class AbstractRestApi(ABC): - @staticmethod - @abstractmethod - def version() -> str | None: - return None - - @abstractmethod - def get_ephemerality(self, - input_vector: Sequence[float], - threshold: Annotated[float, Query(gt=0., le=1.)], - types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] - ) -> ResultSet: - raise NotImplementedError +from abc import ABC, abstractmethod +from typing import Annotated, Sequence +from fastapi import Query +from ephemerality.src import EphemeralitySet + + +class AbstractRestApi(ABC): + @staticmethod + @abstractmethod + def version() -> str | None: + return None + + @abstractmethod + def get_ephemerality(self, + input_vector: Sequence[float], + threshold: Annotated[float, Query(gt=0., le=1.)], + types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] + ) -> EphemeralitySet: + raise NotImplementedError diff --git a/ephemerality/rest/runner.py b/ephemerality/rest/runner.py index 3687eb1..5076734 100644 --- a/ephemerality/rest/runner.py +++ b/ephemerality/rest/runner.py @@ -1,6 +1,6 @@ -from fastapi import FastAPI -from ephemerality.rest import router - - -app = FastAPI() -app.include_router(router) +from fastapi import FastAPI +from ephemerality.rest import router + + +app = FastAPI() +app.include_router(router) diff --git a/ephemerality/scripts/__init__.py b/ephemerality/scripts/__init__.py index af29a1f..03c7596 100644 --- a/ephemerality/scripts/__init__.py +++ b/ephemerality/scripts/__init__.py @@ -1,4 +1,4 @@ -from ephemerality.scripts.ephemerality_api import init_api_argparse -from ephemerality.scripts.ephemerality_cmd import init_cmd_parser - -__all__ = [init_cmd_parser, init_api_argparse] +from ephemerality.scripts.ephemerality_api import init_api_argparse +from ephemerality.scripts.ephemerality_cmd import init_cmd_parser + +__all__ = ['init_cmd_parser', 'init_api_argparse'] diff --git a/ephemerality/scripts/ephemerality_api.py b/ephemerality/scripts/ephemerality_api.py index bf42ae1..4c27170 100644 --- a/ephemerality/scripts/ephemerality_api.py +++ b/ephemerality/scripts/ephemerality_api.py @@ -1,35 +1,35 @@ -from argparse import ArgumentParser, Namespace -from subprocess import call - -from ephemerality.rest import set_test_mode - - -def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: - parser.usage = "%(prog)s [-h] [--host HOST] [--port PORT] [--test] ..." - parser.description = "Start a REST web service to compute ephemerality computations on requests." - parser.add_argument( - "--host", action="store", default="127.0.0.1", - help="Bind socket to this host. Defaults to \"127.0.0.1\"." - ) - parser.add_argument( - "--port", action="store", type=int, default=8080, - help="Bind to a socket with this port. Defaults to 8080." - ) - parser.add_argument( - "--test", action="store_true", - help="Run the web service in a mode that allows to process requests to evaluate time and RAM performance of " - "the module (can be computationally expensive!)." - ) - parser.set_defaults( - func=exec_start_service_call - ) - return parser - - -def start_service(host: str = "127.0.0.1", port: int = 8080, test_mode: bool = False) -> None: - set_test_mode(test_mode) - call(['uvicorn', 'ephemerality.rest.runner:app', '--host', host, '--port', str(port)]) - - -def exec_start_service_call(input_args: Namespace) -> None: - start_service(host=input_args.host, port=input_args.port, test_mode=input_args.test) +from argparse import ArgumentParser, Namespace +from subprocess import call + +from ephemerality.rest import set_test_mode + + +def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: + parser.usage = "%(prog)s [-h] [--host HOST] [--port PORT] [--test] ..." + parser.description = "Start a REST web service to compute ephemerality computations on requests." + parser.add_argument( + "--host", action="store", default="127.0.0.1", + help="Bind socket to this host. Defaults to \"127.0.0.1\"." + ) + parser.add_argument( + "--port", action="store", type=int, default=8080, + help="Bind to a socket with this port. Defaults to 8080." + ) + parser.add_argument( + "--test", action="store_true", + help="Run the web service in a mode that allows to process requests to evaluate time and RAM performance of " + "the module (can be computationally expensive!)." + ) + parser.set_defaults( + func=exec_start_service_call + ) + return parser + + +def start_service(host: str = "127.0.0.1", port: int = 8080, test_mode: bool = False) -> None: + set_test_mode(test_mode) + call(['uvicorn', 'ephemerality.rest.runner:app', '--host', host, '--port', str(port)]) + + +def exec_start_service_call(input_args: Namespace) -> None: + start_service(host=input_args.host, port=input_args.port, test_mode=input_args.test) diff --git a/ephemerality/scripts/ephemerality_cmd.py b/ephemerality/scripts/ephemerality_cmd.py index 8312bde..e128c82 100644 --- a/ephemerality/scripts/ephemerality_cmd.py +++ b/ephemerality/scripts/ephemerality_cmd.py @@ -1,130 +1,130 @@ -import json -import sys -import time -from argparse import ArgumentParser, Namespace, SUPPRESS -from pathlib import Path -from memory_profiler import memory_usage - -import numpy as np -from ephemerality.src import compute_ephemerality, process_input, ProcessedData - - -def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: - parser.usage = "%(prog)s [activity] [-h] [-i INPUT_FILE] [-r] [-o OUTPUT_FILE.json] [-t THRESHOLD]..." - parser.description = "Calculate ephemerality for a given activity vector or a set of timestamps." - parser.add_argument( - "-p", "--print", action="store_true", - help="If an output file is specified, forces the results to still be printed to stdout." - ) - parser.add_argument( - "-i", "--input", action="store", - help="Path to either a JSON or CSV file with input data, or to the folder with files. If not specified, " - "will read the activity vector from the command line (as numbers delimited by either commas or spaces)." - ) - parser.add_argument( - "-r", "--recursive", action="store_true", - help="Used with a folder-type input to specify to also process files in the full subfolder tree. " - "Defaults to False." - ) - parser.add_argument( - "-o", "--output", action="store", - help="Path to an output JSON file. If not specified, will output ephemerality values to stdout in JSON format." - ) - parser.add_argument( - "--output_indent", action="store", type=int, default=-1, - help="Sets the indentation level of the output (either a JSON file or STDOUT) in terms of number of spaces per " - "level. If negative, will output results as a single line. Defaults to -1." - ) - parser.add_argument( - "-t", "--threshold", action="store", type=float, default=0.8, - help="Threshold value for ephemerality computations in case of CSV input. Defaults to 0.8." - ) - parser.add_argument( - "--test_time_reps", action="store", type=int, default=0, - help=SUPPRESS - ) - parser.add_argument( - "--test_ram_reps", action="store", type=int, default=0, - help=SUPPRESS - ) - parser.add_argument( - 'activity', type=float, - help='Activity vector (if the input file is not specified)', - nargs='*' - ) - parser.set_defaults( - func=exec_cmd_compute_call - ) - return parser - - -def exec_cmd_compute_call(input_args: Namespace) -> None: - if input_args.input: - path = Path(input_args.input) - if path.is_dir(): - input_cases = process_input(input_folder=input_args.input, recursive=input_args.recursive) - elif path.is_file(): - input_cases = process_input(input_file=input_args.input, threshold=float(input_args.threshold)) - else: - raise ValueError("Unknown input file format!") - else: - input_cases: list[ProcessedData] = [] - if len(input_args.activity) > 1: - input_cases.append( - ProcessedData( - name="cmd-input", - activity=np.array(input_args.activity, dtype=float), - threshold=float(input_args.threshold))) - elif len(input_args.activity) == 1: - if ' ' in input_args.activity[0]: - input_cases.append( - ProcessedData( - name="cmd-input", - activity=np.array(input_args.activity[0].split(' '), dtype=float), - threshold=float(input_args.threshold))) - else: - input_cases.append( - ProcessedData( - name="cmd-input", - activity=np.array(input_args.activity[0].split(','), dtype=float), - threshold=float(input_args.threshold))) - else: - sys.exit('No input provided!') - - results = {} - - if input_args.test_time_reps > 0 or input_args.test_ram_reps > 0: - if input_args.test_time_reps: - for input_case in input_cases: - results["time"] = dict() - times = [] - for i in range(input_args.test_time_reps): - start_time = time.time() - compute_ephemerality(activity_vector=input_case.activity, threshold=input_case.threshold).dict() - times.append(time.time() - start_time) - results["time"][input_case.name] = times - if input_args.test_ram_reps: - for input_case in input_cases: - results["RAM"] = dict() - rams = [] - for i in range(input_args.test_ram_reps): - rams.append(memory_usage( - (compute_ephemerality, [], {"activity_vector": input_case.activity, "threshold": input_case.threshold}), - max_usage=True - )) - results["RAM"][input_case.name] = rams - else: - for input_case in input_cases: - results[input_case.name] = compute_ephemerality(activity_vector=input_case.activity, - threshold=input_case.threshold).dict() - - output_indent = input_args.output_indent if input_args.output_indent >= 0 else None - if input_args.output: - with open(input_args.output, 'w') as f: - json.dump(results, f, indent=output_indent, sort_keys=True) - if input_args.print: - print(json.dumps(results, indent=output_indent, sort_keys=True)) - else: - return None - else: - print(json.dumps(results, indent=output_indent, sort_keys=True)) +import json +import sys +import time +from argparse import ArgumentParser, Namespace, SUPPRESS +from pathlib import Path +from memory_profiler import memory_usage + +import numpy as np +from ephemerality.src import compute_ephemerality, process_input, ProcessedData + + +def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: + parser.usage = "%(prog)s [activity] [-h] [-i INPUT_FILE] [-r] [-o OUTPUT_FILE.json] [-t THRESHOLD]..." + parser.description = "Calculate ephemerality for a given activity vector or a set of timestamps." + parser.add_argument( + "-p", "--print", action="store_true", + help="If an output file is specified, forces the results to still be printed to stdout." + ) + parser.add_argument( + "-i", "--input", action="store", + help="Path to either a JSON or CSV file with input data, or to the folder with files. If not specified, " + "will read the activity vector from the command line (as numbers delimited by either commas or spaces)." + ) + parser.add_argument( + "-r", "--recursive", action="store_true", + help="Used with a folder-type input to specify to also process files in the full subfolder tree. " + "Defaults to False." + ) + parser.add_argument( + "-o", "--output", action="store", + help="Path to an output JSON file. If not specified, will output ephemerality values to stdout in JSON format." + ) + parser.add_argument( + "--output_indent", action="store", type=int, default=-1, + help="Sets the indentation level of the output (either a JSON file or STDOUT) in terms of number of spaces per " + "level. If negative, will output results as a single line. Defaults to -1." + ) + parser.add_argument( + "-t", "--threshold", action="store", type=float, default=0.8, + help="Threshold value for ephemerality computations in case of CSV input. Defaults to 0.8." + ) + parser.add_argument( + "--test_time_reps", action="store", type=int, default=0, + help=SUPPRESS + ) + parser.add_argument( + "--test_ram_reps", action="store", type=int, default=0, + help=SUPPRESS + ) + parser.add_argument( + 'activity', type=float, + help='Activity vector (if the input file is not specified)', + nargs='*' + ) + parser.set_defaults( + func=exec_cmd_compute_call + ) + return parser + + +def exec_cmd_compute_call(input_args: Namespace) -> None: + if input_args.input: + path = Path(input_args.input) + if path.is_dir(): + input_cases = process_input(input_folder=input_args.input, recursive=input_args.recursive) + elif path.is_file(): + input_cases = process_input(input_file=input_args.input, threshold=float(input_args.threshold)) + else: + raise ValueError("Unknown input file format!") + else: + input_cases: list[ProcessedData] = [] + if len(input_args.activity) > 1: + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array(input_args.activity, dtype=float), + threshold=float(input_args.threshold))) + elif len(input_args.activity) == 1: + if ' ' in input_args.activity[0]: + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array(input_args.activity[0].split(' '), dtype=float), + threshold=float(input_args.threshold))) + else: + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array(input_args.activity[0].split(','), dtype=float), + threshold=float(input_args.threshold))) + else: + sys.exit('No input provided!') + + results = {} + + if input_args.test_time_reps > 0 or input_args.test_ram_reps > 0: + if input_args.test_time_reps: + for input_case in input_cases: + results["time"] = dict() + times = [] + for i in range(input_args.test_time_reps): + start_time = time.time() + compute_ephemerality(activity_vector=input_case.activity, threshold=input_case.threshold).dict() + times.append(time.time() - start_time) + results["time"][input_case.name] = times + if input_args.test_ram_reps: + for input_case in input_cases: + results["RAM"] = dict() + rams = [] + for i in range(input_args.test_ram_reps): + rams.append(memory_usage( + (compute_ephemerality, [], {"activity_vector": input_case.activity, "threshold": input_case.threshold}), + max_usage=True + )) + results["RAM"][input_case.name] = rams + else: + for input_case in input_cases: + results[input_case.name] = compute_ephemerality(activity_vector=input_case.activity, + threshold=input_case.threshold).dict() + + output_indent = input_args.output_indent if input_args.output_indent >= 0 else None + if input_args.output: + with open(input_args.output, 'w') as f: + json.dump(results, f, indent=output_indent, sort_keys=True) + if input_args.print: + print(json.dumps(results, indent=output_indent, sort_keys=True)) + else: + return None + else: + print(json.dumps(results, indent=output_indent, sort_keys=True)) diff --git a/ephemerality/src/__init__.py b/ephemerality/src/__init__.py index 8602d6f..04e58b0 100644 --- a/ephemerality/src/__init__.py +++ b/ephemerality/src/__init__.py @@ -1,5 +1,5 @@ -from ephemerality.src.data_processing import process_input, InputData, ProcessedData -from ephemerality.src.ephemerality_computation import compute_ephemerality -from ephemerality.src.utils import ResultSet - -__all__ = [compute_ephemerality, ResultSet, process_input, InputData, ProcessedData] +from .data_processing import process_input, InputData, ProcessedData +from .ephemerality_computation import compute_ephemerality +from .utils import EphemeralitySet + +__all__ = ['compute_ephemerality', 'EphemeralitySet', 'process_input', 'InputData', 'ProcessedData'] diff --git a/ephemerality/src/data_processing.py b/ephemerality/src/data_processing.py index 5f5eed8..b3dd170 100644 --- a/ephemerality/src/data_processing.py +++ b/ephemerality/src/data_processing.py @@ -1,193 +1,193 @@ -import json -import warnings -from dataclasses import dataclass -from datetime import datetime, timezone, timedelta -from pathlib import Path -from typing import Sequence - -import numpy as np -from pydantic import BaseModel - -SECONDS_WEEK = 604800. -SECONDS_DAY = 86400. -SECONDS_HOUR = 3600. - - -class InputData(BaseModel): - """ - POST request body format - """ - input_sequence: list[str] - input_type: str = 'a' # 'activity' | 'a' | 'timestamps' | 't' | 'datetime' | 'd' - threshold: float = 0.8 - time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format - timezone: float = 0. # used only if input_type == 'datetime' | 'd'. Offset in hours from the UTC time. Should be within [-24, +24] range. - range: None | tuple[ - str, str] = None # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd', defaults to (min(input), max(input)) - granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd'. {'week', 'day', 'hour', '_d', '_h'} - reference_name: str = "" - - -@dataclass -class ProcessedData: - name: str - activity: np.ndarray[float] - threshold: float = 0.8 - - -def process_input( - input_folder: str | Path | None = None, - recursive: bool = True, - input_file: str | Path | None = None, - input_remote_data: InputData | None = None, - input_dict: dict | None = None, - input_seq: Sequence[float | int | str] | None = None, - threshold: float = 0.8) -> list[ProcessedData]: - output = [] - - if input_folder: - output.extend(process_folder(path=Path(input_folder), recursive=recursive, threshold=threshold)) - - if input_file: - output.extend(process_file(path=Path(input_file), threshold=threshold)) - - if input_remote_data: - output.append(process_formatted_data(input_remote_data)) - - if input_dict: - output.append(process_formatted_data(InputData(**input_dict))) - - if input_seq: - if threshold is None: - raise ValueError('Threshold value is not defined!') - output.append(ProcessedData(name="sequence", activity=np.ndarray(input_seq, dtype=float), threshold=threshold)) - - return output - - -def process_folder(path: Path, recursive: bool = True, threshold: float | None = None) -> list[ProcessedData]: - output = [] - for file in path.iterdir(): - if file.is_file(): - output.extend(process_file(path=file, threshold=threshold)) - elif file.is_dir() and recursive: - output.extend(process_folder(path=file, recursive=recursive, threshold=threshold)) - return output - - -def process_file(path: Path, threshold: float | None = None) -> list[ProcessedData]: - if path.suffix == '.json': - return process_json(path) - elif path.suffix == '.csv': - return [ProcessedData(name=f"{str(path.resolve())}[{i}]", activity=sequence, threshold=threshold) - for i, sequence in enumerate(process_csv(path))] - else: - return [] - - -def process_json(path: Path) -> list[ProcessedData]: - with open(path, 'r') as f: - input_object = json.load(f) - - if isinstance(input_object, dict): - input_object = [input_object] - - output = [] - for i, input_case in enumerate(input_object): - input_case = InputData(**input_case) - try: - case_output = process_formatted_data(input_case) - if not case_output.name: - case_output.name = f"{str(path.resolve())}[{i}]" - output.append(case_output) - except ValueError: - warnings.warn( - f'\"input_type\" is not one of [\"activity\", \"a\", \"timestamps\", \"t\", \"datetime\", \"d\"]!' - f' Ignoring file \"{str(path.resolve())}\"!') - - return output - - -def process_formatted_data(input_data: InputData) -> ProcessedData: - if input_data.input_type == 'activity' or input_data.input_type == 'a': - return ProcessedData( - name=input_data.reference_name, - activity=np.array(input_data.input_sequence, dtype=float), - threshold=input_data.threshold - ) - elif input_data.input_type == 'timestamps' or input_data.input_type == 't': - return ProcessedData( - name=input_data.reference_name, - activity=timestamps_to_activity(np.array(input_data.input_sequence, dtype=float), - input_data.range, - input_data.granularity), - threshold=input_data.threshold - ) - elif input_data.input_type == 'datetime' or input_data.input_type == 'd': - timestamps = [datetime.strptime(time_point, input_data.time_format).replace( - tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() - for time_point in input_data.input_sequence] - if input_data.range is not None: - ts_range = ( - datetime.strptime(input_data.range[0], input_data.time_format).replace( - tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp(), - datetime.strptime(input_data.range[1], input_data.time_format).replace( - tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() - ) - else: - ts_range = None - return ProcessedData( - name=input_data.reference_name, - activity=timestamps_to_activity(np.array(timestamps, dtype=float), ts_range, input_data.granularity), - threshold=input_data.threshold - ) - else: - raise ValueError("Wrong \"input_type\" value!") - - -def process_csv(path: Path) -> list[np.ndarray[float]]: - output = [] - with open(path, 'r') as f: - for line in f: - if line: - output.append(np.fromstring(line.strip(), dtype=float, sep=',')) - return output - - -def timestamps_to_activity(timestamps: Sequence[float | int | str], - ts_range: None | tuple[float | int | str, float | int | str] = None, - granularity: str = 'day') -> np.ndarray[float]: - if not isinstance(timestamps, np.ndarray) or timestamps.dtype != float: - timestamps = np.array(timestamps, dtype=float) - if ts_range is None: - ts_range = (np.min(timestamps), np.max(timestamps)) - if granularity == 'week': - bin_width = SECONDS_WEEK - elif granularity == 'day': - bin_width = SECONDS_DAY - elif granularity == 'hour': - bin_width = SECONDS_HOUR - elif granularity[-1] == 'd' and _is_float(granularity[:-1]): - bin_width = float(granularity[:-1]) * SECONDS_DAY - elif granularity[-1] == 'h' and _is_float(granularity[:-1]): - bin_width = float(granularity[:-1]) * SECONDS_HOUR - else: - raise ValueError(f"Invalid granularity value: {granularity}!") - - # print(f"\n\nDEBUG: ts_range[0]: {ts_range[0]}, ts_range[1]: {ts_range[1]}, bin_width: {bin_width}\n\n") - - bins = np.arange(ts_range[0], ts_range[1], bin_width) - if not np.isclose(bins[-1], ts_range[1]): - bins = np.append(bins, ts_range[1]) - - activity, _ = np.histogram(np.array(timestamps, dtype=float), bins=bins) - activity.dtype = float - return activity - - -def _is_float(num: str) -> bool: - try: - float(num) - except ValueError: - return False - return True +import json +import warnings +from dataclasses import dataclass +from datetime import datetime, timezone, timedelta +from pathlib import Path +from typing import Sequence + +import numpy as np +from pydantic import BaseModel + +SECONDS_WEEK = 604800. +SECONDS_DAY = 86400. +SECONDS_HOUR = 3600. + + +class InputData(BaseModel): + """ + POST request body format + """ + input_sequence: list[str] + input_type: str = 'a' # 'activity' | 'a' | 'timestamps' | 't' | 'datetime' | 'd' + threshold: float = 0.8 + time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format + timezone: float = 0. # used only if input_type == 'datetime' | 'd'. Offset in hours from the UTC time. Should be within [-24, +24] range. + range: None | tuple[ + str, str] = None # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd', defaults to (min(input), max(input)) + granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd'. {'week', 'day', 'hour', '_d', '_h'} + reference_name: str = "" + + +@dataclass +class ProcessedData: + name: str + activity: np.ndarray[float] + threshold: float = 0.8 + + +def process_input( + input_folder: str | Path | None = None, + recursive: bool = True, + input_file: str | Path | None = None, + input_remote_data: InputData | None = None, + input_dict: dict | None = None, + input_seq: Sequence[float | int | str] | None = None, + threshold: float = 0.8) -> list[ProcessedData]: + output = [] + + if input_folder: + output.extend(process_folder(path=Path(input_folder), recursive=recursive, threshold=threshold)) + + if input_file: + output.extend(process_file(path=Path(input_file), threshold=threshold)) + + if input_remote_data: + output.append(process_formatted_data(input_remote_data)) + + if input_dict: + output.append(process_formatted_data(InputData(**input_dict))) + + if input_seq: + if threshold is None: + raise ValueError('Threshold value is not defined!') + output.append(ProcessedData(name="sequence", activity=np.ndarray(input_seq, dtype=float), threshold=threshold)) + + return output + + +def process_folder(path: Path, recursive: bool = True, threshold: float | None = None) -> list[ProcessedData]: + output = [] + for file in path.iterdir(): + if file.is_file(): + output.extend(process_file(path=file, threshold=threshold)) + elif file.is_dir() and recursive: + output.extend(process_folder(path=file, recursive=recursive, threshold=threshold)) + return output + + +def process_file(path: Path, threshold: float | None = None) -> list[ProcessedData]: + if path.suffix == '.json': + return process_json(path) + elif path.suffix == '.csv': + return [ProcessedData(name=f"{str(path.resolve())}[{i}]", activity=sequence, threshold=threshold) + for i, sequence in enumerate(process_csv(path))] + else: + return [] + + +def process_json(path: Path) -> list[ProcessedData]: + with open(path, 'r') as f: + input_object = json.load(f) + + if isinstance(input_object, dict): + input_object = [input_object] + + output = [] + for i, input_case in enumerate(input_object): + input_case = InputData(**input_case) + try: + case_output = process_formatted_data(input_case) + if not case_output.name: + case_output.name = f"{str(path.resolve())}[{i}]" + output.append(case_output) + except ValueError: + warnings.warn( + f'\"input_type\" is not one of [\"activity\", \"a\", \"timestamps\", \"t\", \"datetime\", \"d\"]!' + f' Ignoring file \"{str(path.resolve())}\"!') + + return output + + +def process_formatted_data(input_data: InputData) -> ProcessedData: + if input_data.input_type == 'activity' or input_data.input_type == 'a': + return ProcessedData( + name=input_data.reference_name, + activity=np.array(input_data.input_sequence, dtype=float), + threshold=input_data.threshold + ) + elif input_data.input_type == 'timestamps' or input_data.input_type == 't': + return ProcessedData( + name=input_data.reference_name, + activity=timestamps_to_activity(np.array(input_data.input_sequence, dtype=float), + input_data.range, + input_data.granularity), + threshold=input_data.threshold + ) + elif input_data.input_type == 'datetime' or input_data.input_type == 'd': + timestamps = [datetime.strptime(time_point, input_data.time_format).replace( + tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() + for time_point in input_data.input_sequence] + if input_data.range is not None: + ts_range = ( + datetime.strptime(input_data.range[0], input_data.time_format).replace( + tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp(), + datetime.strptime(input_data.range[1], input_data.time_format).replace( + tzinfo=timezone(timedelta(hours=input_data.timezone))).timestamp() + ) + else: + ts_range = None + return ProcessedData( + name=input_data.reference_name, + activity=timestamps_to_activity(np.array(timestamps, dtype=float), ts_range, input_data.granularity), + threshold=input_data.threshold + ) + else: + raise ValueError("Wrong \"input_type\" value!") + + +def process_csv(path: Path) -> list[np.ndarray[float]]: + output = [] + with open(path, 'r') as f: + for line in f: + if line: + output.append(np.fromstring(line.strip(), dtype=float, sep=',')) + return output + + +def timestamps_to_activity(timestamps: Sequence[float | int | str], + ts_range: None | tuple[float | int | str, float | int | str] = None, + granularity: str = 'day') -> np.ndarray[float]: + if not isinstance(timestamps, np.ndarray) or timestamps.dtype != float: + timestamps = np.array(timestamps, dtype=float) + if ts_range is None: + ts_range = (np.min(timestamps), np.max(timestamps)) + if granularity == 'week': + bin_width = SECONDS_WEEK + elif granularity == 'day': + bin_width = SECONDS_DAY + elif granularity == 'hour': + bin_width = SECONDS_HOUR + elif granularity[-1] == 'd' and _is_float(granularity[:-1]): + bin_width = float(granularity[:-1]) * SECONDS_DAY + elif granularity[-1] == 'h' and _is_float(granularity[:-1]): + bin_width = float(granularity[:-1]) * SECONDS_HOUR + else: + raise ValueError(f"Invalid granularity value: {granularity}!") + + # print(f"\n\nDEBUG: ts_range[0]: {ts_range[0]}, ts_range[1]: {ts_range[1]}, bin_width: {bin_width}\n\n") + + bins = np.arange(ts_range[0], ts_range[1], bin_width) + if not np.isclose(bins[-1], ts_range[1]): + bins = np.append(bins, ts_range[1]) + + activity, _ = np.histogram(np.array(timestamps, dtype=float), bins=bins) + activity.dtype = float + return activity + + +def _is_float(num: str) -> bool: + try: + float(num) + except ValueError: + return False + return True diff --git a/ephemerality/src/ephemerality_computation.py b/ephemerality/src/ephemerality_computation.py index 77d4e8a..b49d37c 100644 --- a/ephemerality/src/ephemerality_computation.py +++ b/ephemerality/src/ephemerality_computation.py @@ -1,140 +1,352 @@ -from typing import Sequence - -import numpy as np -from ephemerality.src.utils import ResultSet - - -def _check_threshold(threshold: float) -> bool: - if threshold <= 0.: - raise ValueError('Threshold value must be greater than 0!') - - if threshold > 1.: - raise ValueError('Threshold value must be less or equal to 1!') - - return True - - -def _ephemerality_raise_error(threshold: float): - if _check_threshold(threshold): - raise ValueError('Input activity vector has not been internally normalized (problematic data format?)!') - - -def _normalize_activity_vector(activity_vector: Sequence[float]) -> np.array: - activity_vector = np.array(activity_vector) - - if sum(activity_vector) != 1.: - activity_vector /= np.sum(activity_vector) - - return activity_vector - - -def compute_left_core_length(activity_vector: np.array, threshold: float) -> int: - current_sum = 0 - for i, freq in enumerate(activity_vector): - current_sum = current_sum + freq - if np.isclose(current_sum, threshold) or current_sum > threshold: - return i + 1 - - _ephemerality_raise_error(threshold) - - -def compute_right_core_length(activity_vector: np.array, threshold: float) -> int: - current_sum = 0 - for i, freq in enumerate(activity_vector[::-1]): - current_sum = current_sum + freq - if np.isclose(current_sum, threshold) or current_sum > threshold: - return i + 1 - - _ephemerality_raise_error(threshold) - - -def compute_middle_core_length(activity_vector: np.array, threshold: float) -> int: - lower_threshold = (1. - threshold) / 2 - - current_left_sum = 0 - start_index = -1 - for i, freq in enumerate(activity_vector): - current_left_sum += freq - if current_left_sum > lower_threshold and not np.isclose(current_left_sum, lower_threshold): - start_index = i - break - - current_sum = 0 - for j, freq in enumerate(activity_vector[start_index:]): - current_sum += freq - if np.isclose(current_sum, threshold) or current_sum > threshold: - return j + 1 - - _ephemerality_raise_error(threshold) - - -def compute_sorted_core_length(activity_vector: np.array, threshold: float) -> int: - freq_descending_order = np.sort(activity_vector)[::-1] - - current_sum = 0 - for i, freq in enumerate(freq_descending_order): - current_sum += freq - if np.isclose(current_sum, threshold) or current_sum > threshold: - return i + 1 - - _ephemerality_raise_error(threshold) - - -def _compute_ephemerality_from_core(core_length: int, range_length: int, threshold: float): - return max(0., 1 - (core_length / range_length) / threshold) - - -def compute_ephemerality( - activity_vector: Sequence[float], - threshold: float = 0.8, - types: str = 'lmrs') -> ResultSet: - - _check_threshold(threshold) - - if np.sum(activity_vector) == 0.: - raise ZeroDivisionError("Activity vector's sum is 0!") - - activity_vector = _normalize_activity_vector(activity_vector) - range_length = len(activity_vector) - - if 'l' in types: - length_left_core = compute_left_core_length(activity_vector, threshold) - ephemerality_left_core = _compute_ephemerality_from_core(length_left_core, range_length, threshold) - else: - length_left_core = None - ephemerality_left_core = None - - if 'm' in types: - length_middle_core = compute_middle_core_length(activity_vector, threshold) - ephemerality_middle_core = _compute_ephemerality_from_core(length_middle_core, range_length, threshold) - else: - length_middle_core = None - ephemerality_middle_core = None - - if 'r' in types: - length_right_core = compute_right_core_length(activity_vector, threshold) - ephemerality_right_core = _compute_ephemerality_from_core(length_right_core, range_length, threshold) - else: - length_right_core = None - ephemerality_right_core = None - - if 's' in types: - length_sorted_core = compute_sorted_core_length(activity_vector, threshold) - ephemerality_sorted_core = _compute_ephemerality_from_core(length_sorted_core, range_length, threshold) - else: - length_sorted_core = None - ephemerality_sorted_core = None - - ephemeralities = ResultSet( - len_left_core=length_left_core, - len_middle_core=length_middle_core, - len_right_core=length_right_core, - len_sorted_core=length_sorted_core, - - eph_left_core=ephemerality_left_core, - eph_middle_core=ephemerality_middle_core, - eph_right_core=ephemerality_right_core, - eph_sorted_core=ephemerality_sorted_core - ) - - return ephemeralities +from typing import Sequence + +import numpy as np +from numpy.typing import NDArray +from matplotlib import pyplot as plt +from matplotlib.axes import Axes +from matplotlib.figure import Figure +from .utils import EphemeralitySet + + +def _check_threshold(threshold: float) -> bool: + if threshold <= 0.: + raise ValueError('Threshold value must be greater than 0!') + + if threshold > 1.: + raise ValueError('Threshold value must be less or equal to 1!') + + return True + + +def _ephemerality_raise_error(threshold: float) -> None: + if _check_threshold(threshold): + raise ValueError('Input activity vector has not been internally normalized (problematic data format?)!') + + +def _normalize_activity_vector(activity_vector: Sequence[float]) -> NDArray: + activity_vector = np.array(activity_vector, dtype=np.float64) + + if sum(activity_vector) != 1.: + activity_vector /= np.sum(activity_vector) + + return activity_vector + + +def _str_to_core_types(type_str: str) -> tuple[set[str], int]: + types = set() + for c in type_str.lower(): + match c: + case 'l': + types.add('l') + case 'm': + types.add('m') + case 'r': + types.add('r') + case 's': + types.add('s') + case _: + raise ValueError(f'Unrecognized core type: {c}') + n_types = len(types) + return types, n_types + + +def _init_fig(core_types: set[str]) -> tuple[Figure, list[Axes]]: + fig = plt.figure() + n_cores = len(core_types) + axes = list() + match n_cores: + case 1: + gs = fig.add_gridspec(nrows=1, ncols=1) + grid = [gs[0, 0]] + case 2: + gs = fig.add_gridspec(nrows=1, ncols=2) + grid = [gs[0, 0], gs[0, 1]] + case 3: + gs = fig.add_gridspec(nrows=2, ncols=1) + gs_0 = gs[0].subgridspec(nrows=1, ncols=2) + gs_1 = gs[1].subgridspec(nrows=1, ncols=3, width_ratios=[1, 2, 1]) + grid = [gs_0[0, 0], gs_0[0, 1], gs_1[0, 1]] + case 4: + gs = fig.add_gridspec(nrows=2, ncols=2) + grid = [gs[0, 0], gs[0, 1], gs[1, 0], gs[1, 1]] + for i in range(n_cores): + axes.append(fig.add_subplot(grid[i])) + + return fig, axes + + +def _annotate_ax(ax: Axes, x_len: int, core_type: str, core_length: int, ephemerality: float) -> Axes: + ax.set_xlim((0, x_len)) + ax.set_xlabel('Time') + ax.set_ylabel('Normalized activity') + ax.set_title(rf'{core_type} core (length {core_length}), $\varepsilon={np.round(ephemerality, 3)}$') + return ax + + +def compute_left_core_length(activity_vector: NDArray, threshold: float, axes: Axes | None = None) -> int: + """ + Compute the length of the left core of the activity vector. + + Parameters + ---------- + activity_vector : numpy.typing.NDArray + A normalized sequence of activity values. Time bins corresponding to each value is assumed to be of equal + length. + threshold : float + Ratio of activity that is considered to comprise its core part. + axes : Optional[Axes] + If provided, will plot the histogram of the activity vector and color its core part on it. + + Returns + ------- + int + The length of the left core period of the activity vector. + """ + current_sum = 0 + for i, freq in enumerate(activity_vector): + current_sum = current_sum + freq + if np.isclose(current_sum, threshold) or current_sum > threshold: + if axes is not None: + axes.stairs(activity_vector[:(i + 1)], np.arange(i + 2), fill=True, color='C1') + axes.stairs(activity_vector, np.arange(len(activity_vector) + 1), fill=False, color='C0') + return i + 1 + + _ephemerality_raise_error(threshold) + + +def compute_right_core_length(activity_vector: NDArray, threshold: float, axes: Axes | None = None) -> int: + """ + Compute the length of the right core of the activity vector. + + Parameters + ---------- + activity_vector : numpy.typing.NDArray + A normalized sequence of activity values. Time bins corresponding to each value is assumed to be of equal + length. + threshold : float + Ratio of activity that is considered to comprise its core part. + axes : Optional[Axes] + If provided, will plot the histogram of the activity vector and color its core part on it. + + Returns + ------- + int + The length of the right core period of the activity vector. + """ + current_sum = 0 + for i, freq in enumerate(activity_vector[::-1]): + current_sum = current_sum + freq + if np.isclose(current_sum, threshold) or current_sum > threshold: + if axes is not None: + bound = len(activity_vector) - (i + 1) + axes.stairs(activity_vector[bound:], np.arange(bound, len(activity_vector) + 1), fill=True, color='C1') + axes.stairs(activity_vector, np.arange(len(activity_vector) + 1), fill=False, color='C0') + return i + 1 + + _ephemerality_raise_error(threshold) + + +def compute_middle_core_length(activity_vector: NDArray, threshold: float, axes: Axes | None = None) -> int: + """ + Compute the length of the middle core of the activity vector. + + Parameters + ---------- + activity_vector : numpy.typing.NDArray + A normalized sequence of activity values. Time bins corresponding to each value is assumed to be of equal + length. + threshold : float + Ratio of activity that is considered to comprise its core part. + axes : Optional[Axes] + If provided, will plot the histogram of the activity vector and color its core part on it. + + Returns + ------- + int + The length of the middle core period of the activity vector. + """ + lower_threshold = (1. - threshold) / 2 + + current_left_sum = 0 + start_index = -1 + for i, freq in enumerate(activity_vector): + current_left_sum += freq + if current_left_sum > lower_threshold and not np.isclose(current_left_sum, lower_threshold): + start_index = i + break + + current_sum = 0 + for j, freq in enumerate(activity_vector[start_index:]): + current_sum += freq + if np.isclose(current_sum, threshold) or current_sum > threshold: + if axes is not None: + axes.stairs(activity_vector[start_index:(start_index + j + 1)], np.arange(start_index, start_index + j + 2), fill=True, color='C1') + axes.stairs(activity_vector, np.arange(len(activity_vector) + 1), fill=False, color='C0') + return j + 1 + + _ephemerality_raise_error(threshold) + + +def compute_sorted_core_length(activity_vector: np.array, threshold: float, axes: Axes | None = None) -> int: + """ + Compute the length of the sorted core of the activity vector. + + Parameters + ---------- + activity_vector : numpy.typing.NDArray + A normalized sequence of activity values. Time bins corresponding to each value is assumed to be of equal + length. + threshold : float + Ratio of activity that is considered to comprise its core part. + axes : Optional[Axes] + If provided, will plot the histogram of the activity vector and color its core part on it. + + Returns + ------- + int + The length of the sorted core period of the activity vector. + """ + indices = np.argsort(activity_vector)[::-1] + freq_descending_order = activity_vector[indices] + + current_sum = 0 + for i, freq in enumerate(freq_descending_order): + current_sum += freq + if np.isclose(current_sum, threshold) or current_sum > threshold: + if axes is not None: + core = np.zeros((len(activity_vector),)) + core[indices[:(i + 1)]] = activity_vector[indices[:(i + 1)]] + axes.stairs(core, np.arange(len(activity_vector) + 1), fill=True, color='C1') + + axes.stairs(activity_vector, np.arange(len(activity_vector) + 1), fill=False, color='C0') + return i + 1 + + _ephemerality_raise_error(threshold) + + +def _compute_ephemerality_from_core(core_length: int, range_length: int, threshold: float) -> float: + return max(0., 1 - (core_length / range_length) / threshold) + + +def _plot(axes: list[Axes]) -> None: + fig = plt.figure() + n_cores = len(axes) + + +def compute_ephemerality( + activity_vector: Sequence[float | int], + threshold: float = 0.8, + types: str = 'lmrs', + plot: bool = False) -> EphemeralitySet: + """Compute ephemerality values for given activity vector. + + This function computes ephemerality for a numeric vector using all current definitions of actiovity cores. + Alpha (desired non-ephemeral core length) can be specified with ``threshold parameter. In case not all cores are + needed, the required types can be specified in ``types``. + + Parameters + ---------- + activity_vector : Sequence[float | int] + A sequence of activity values. Time bins corresponding to each value is assumed to be of equal length. Does not + need to be normalised. + threshold : float, default=0.8 + Desired non-ephemeral core length. Ephemerality is equal to 1. if the core length is at least ``threshold`` of + the ``activity_vector`` length. + types : str, default='lmrs' + Activity cores to be computed. A sequence of characters corresponding to core types. + 'l' for left core, 'm' for middle core, 'r' for right core, 's' for sorted core. Multiples of the same character + will be ignored. + plot : bool, default=False + Set to True to display the activity over time plot with core periods highlighted. + + Returns + ------- + EphemeralitySet + Container for the computed core lengths and ephemerality values + """ + _check_threshold(threshold) + + if np.sum(activity_vector) == 0.: + raise ZeroDivisionError("Activity vector's sum is 0!") + types, n_cores = _str_to_core_types(types) + + activity_vector = _normalize_activity_vector(activity_vector) + len_range = len(activity_vector) + + if plot: + fig, axes = _init_fig(types) + else: + axes = None + subplot_types = list() + + core_ind = 0 + if 'l' in types: + ax = axes[core_ind] if plot else None + subplot_types.append('l') + length_left_core = compute_left_core_length(activity_vector, threshold, axes=ax) + ephemerality_left_core = _compute_ephemerality_from_core(length_left_core, len_range, threshold) + core_ind += 1 + else: + length_left_core = None + ephemerality_left_core = None + + if 'm' in types: + ax = axes[core_ind] if plot else None + subplot_types.append('m') + length_middle_core = compute_middle_core_length(activity_vector, threshold, axes=ax) + ephemerality_middle_core = _compute_ephemerality_from_core(length_middle_core, len_range, threshold) + core_ind += 1 + else: + length_middle_core = None + ephemerality_middle_core = None + + if 'r' in types: + ax = axes[core_ind] if plot else None + subplot_types.append('r') + length_right_core = compute_right_core_length(activity_vector, threshold, axes=ax) + ephemerality_right_core = _compute_ephemerality_from_core(length_right_core, len_range, threshold) + core_ind += 1 + else: + length_right_core = None + ephemerality_right_core = None + + if 's' in types: + ax = axes[core_ind] if plot else None + subplot_types.append('s') + length_sorted_core = compute_sorted_core_length(activity_vector, threshold, axes=ax) + ephemerality_sorted_core = _compute_ephemerality_from_core(length_sorted_core, len_range, threshold) + core_ind += 1 + else: + length_sorted_core = None + ephemerality_sorted_core = None + + if n_cores == 0: + raise ValueError('No valid ephemerality cores requested!') + + ephemeralities = EphemeralitySet( + len_left_core=length_left_core, + len_middle_core=length_middle_core, + len_right_core=length_right_core, + len_sorted_core=length_sorted_core, + + eph_left_core=ephemerality_left_core, + eph_middle_core=ephemerality_middle_core, + eph_right_core=ephemerality_right_core, + eph_sorted_core=ephemerality_sorted_core + ) + + if plot: + for i, subplot_type in enumerate(subplot_types): + match subplot_type: + case 'l': + _annotate_ax(axes[i], len_range, 'Left', ephemeralities.len_left_core, ephemeralities.eph_left_core) + case 'm': + _annotate_ax(axes[i], len_range, 'Middle', ephemeralities.len_middle_core, ephemeralities.eph_middle_core) + case 'r': + _annotate_ax(axes[i], len_range, 'Right', ephemeralities.len_right_core, ephemeralities.eph_right_core) + case 's': + _annotate_ax(axes[i], len_range, 'Sorted', ephemeralities.len_sorted_core, ephemeralities.eph_sorted_core) + fig.tight_layout() + fig.show() + + return ephemeralities diff --git a/ephemerality/src/utils.py b/ephemerality/src/utils.py index bfdc32f..84cbb54 100644 --- a/ephemerality/src/utils.py +++ b/ephemerality/src/utils.py @@ -1,32 +1,64 @@ -import numpy as np -from pydantic import BaseModel - - -class ResultSet(BaseModel): - """Class to contain ephemerality and core size values by subtypes""" - len_left_core: int | None = None - len_middle_core: int | None = None - len_right_core: int | None = None - len_sorted_core: int | None = None - - eph_left_core: float | None = None - eph_middle_core: float | None = None - eph_right_core: float | None = None - eph_sorted_core: float | None = None - - def __eq__(self, other) -> bool: - if isinstance(other, ResultSet): - if \ - self.len_left_core != other.len_left_core or \ - self.len_middle_core != other.len_middle_core or \ - self.len_right_core != other.len_right_core or \ - self.len_sorted_core != other.len_sorted_core or \ - not np.isclose(self.eph_left_core, other.eph_left_core) or \ - not np.isclose(self.eph_middle_core, other.eph_middle_core) or \ - not np.isclose(self.eph_right_core, other.eph_right_core) or \ - not np.isclose(self.eph_sorted_core, other.eph_sorted_core): - return False - else: - return True - else: - return False +import numpy as np +from pydantic import BaseModel + + +class EphemeralitySet(BaseModel): + """ + Container for ephemerality and core size values. + + This class is a simple pydantic BaseModel used to store computed core lengths and corresponding ephemerality values + by core type. Values that were not computed default to None. + + Attributes + ---------- + len_left_core : int, optional + Length of the left core in time bins + len_middle_core : int, optional + Length of the middle core in time bins + len_right_core : int, optional + Length of the right core in time bins + len_sorted_core : int, optional + Length of the sorted core in time bins + + eph_left_core: float, optional + Ephemerality value for the left core + eph_middle_core: float, optional + Ephemerality value for the middle core + eph_right_core: float, optional + Ephemerality value for the right core + eph_sorted_core: float, optional + Ephemerality value for the sorted core + """ + len_left_core: int | None = None + len_middle_core: int | None = None + len_right_core: int | None = None + len_sorted_core: int | None = None + + eph_left_core: float | None = None + eph_middle_core: float | None = None + eph_right_core: float | None = None + eph_sorted_core: float | None = None + + def __eq__(self, other) -> bool: + if isinstance(other, EphemeralitySet): + if \ + self.len_left_core != other.len_left_core or \ + self.len_middle_core != other.len_middle_core or \ + self.len_right_core != other.len_right_core or \ + self.len_sorted_core != other.len_sorted_core or \ + not np.isclose(self.eph_left_core, other.eph_left_core) or \ + not np.isclose(self.eph_middle_core, other.eph_middle_core) or \ + not np.isclose(self.eph_right_core, other.eph_right_core) or \ + not np.isclose(self.eph_sorted_core, other.eph_sorted_core): + return False + else: + return True + else: + return False + + def __str__(self) -> str: + values = ', '.join([f'{pair[0]}={pair[1]}' for pair in sorted(list(self.dict(exclude_none=True).items()), key=lambda x: x[0])]) + return f'{self.__class__.__name__}({values})' + + def __repr__(self) -> str: + return str(self) diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..dc4d364 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,2744 @@ +# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. + +[[package]] +name = "annotated-types" +version = "0.6.0" +description = "Reusable constraint types to use with typing.Annotated" +optional = false +python-versions = ">=3.8" +files = [ + {file = "annotated_types-0.6.0-py3-none-any.whl", hash = "sha256:0641064de18ba7a25dee8f96403ebc39113d0cb953a01429249d5c7564666a43"}, + {file = "annotated_types-0.6.0.tar.gz", hash = "sha256:563339e807e53ffd9c267e99fc6d9ea23eb8443c08f112651963e24e22f84a5d"}, +] + +[[package]] +name = "anyio" +version = "4.3.0" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +optional = false +python-versions = ">=3.8" +files = [ + {file = "anyio-4.3.0-py3-none-any.whl", hash = "sha256:048e05d0f6caeed70d731f3db756d35dcc1f35747c8c403364a8332c630441b8"}, + {file = "anyio-4.3.0.tar.gz", hash = "sha256:f75253795a87df48568485fd18cdd2a3fa5c4f7c5be8e5e36637733fce06fed6"}, +] + +[package.dependencies] +exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} +idna = ">=2.8" +sniffio = ">=1.1" +typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""} + +[package.extras] +doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] +test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] +trio = ["trio (>=0.23)"] + +[[package]] +name = "appnope" +version = "0.1.4" +description = "Disable App Nap on macOS >= 10.9" +optional = false +python-versions = ">=3.6" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +description = "Argon2 for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[package.dependencies] +argon2-cffi-bindings = "*" + +[package.extras] +dev = ["argon2-cffi[tests,typing]", "tox (>4)"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] +tests = ["hypothesis", "pytest"] +typing = ["mypy"] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +description = "Low-level CFFI bindings for Argon2" +optional = false +python-versions = ">=3.6" +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, +] + +[package.dependencies] +cffi = ">=1.0.1" + +[package.extras] +dev = ["cogapp", "pre-commit", "pytest", "wheel"] +tests = ["pytest"] + +[[package]] +name = "arrow" +version = "1.3.0" +description = "Better dates & times for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[package.dependencies] +python-dateutil = ">=2.7.0" +types-python-dateutil = ">=2.8.10" + +[package.extras] +doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] + +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "async-lru" +version = "2.0.4" +description = "Simple LRU cache for asyncio" +optional = false +python-versions = ">=3.8" +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} + +[[package]] +name = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "babel" +version = "2.14.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Babel-2.14.0-py3-none-any.whl", hash = "sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287"}, + {file = "Babel-2.14.0.tar.gz", hash = "sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363"}, +] + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +description = "Screen-scraping library" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +cchardet = ["cchardet"] +chardet = ["chardet"] +charset-normalizer = ["charset-normalizer"] +html5lib = ["html5lib"] +lxml = ["lxml"] + +[[package]] +name = "bleach" +version = "6.1.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.8" +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.3)"] + +[[package]] +name = "certifi" +version = "2024.2.2" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"}, + {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, +] + +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +optional = false +python-versions = ">=3.8" +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[package.dependencies] +traitlets = ">=4" + +[package.extras] +test = ["pytest"] + +[[package]] +name = "contourpy" +version = "1.2.1" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.9" +files = [ + {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"}, + {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"}, + {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"}, + {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"}, + {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"}, + {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"}, + {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"}, + {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"}, + {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"}, + {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"}, + {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"}, +] + +[package.dependencies] +numpy = ">=1.20" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"] + +[[package]] +name = "cycler" +version = "0.12.1" +description = "Composable style cycles" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + +[[package]] +name = "debugpy" +version = "1.8.1" +description = "An implementation of the Debug Adapter Protocol for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "debugpy-1.8.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3bda0f1e943d386cc7a0e71bfa59f4137909e2ed947fb3946c506e113000f741"}, + {file = "debugpy-1.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dda73bf69ea479c8577a0448f8c707691152e6c4de7f0c4dec5a4bc11dee516e"}, + {file = "debugpy-1.8.1-cp310-cp310-win32.whl", hash = "sha256:3a79c6f62adef994b2dbe9fc2cc9cc3864a23575b6e387339ab739873bea53d0"}, + {file = "debugpy-1.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:7eb7bd2b56ea3bedb009616d9e2f64aab8fc7000d481faec3cd26c98a964bcdd"}, + {file = "debugpy-1.8.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:016a9fcfc2c6b57f939673c874310d8581d51a0fe0858e7fac4e240c5eb743cb"}, + {file = "debugpy-1.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd97ed11a4c7f6d042d320ce03d83b20c3fb40da892f994bc041bbc415d7a099"}, + {file = "debugpy-1.8.1-cp311-cp311-win32.whl", hash = "sha256:0de56aba8249c28a300bdb0672a9b94785074eb82eb672db66c8144fff673146"}, + {file = "debugpy-1.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a9fe0829c2b854757b4fd0a338d93bc17249a3bf69ecf765c61d4c522bb92a8"}, + {file = "debugpy-1.8.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3ebb70ba1a6524d19fa7bb122f44b74170c447d5746a503e36adc244a20ac539"}, + {file = "debugpy-1.8.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2e658a9630f27534e63922ebf655a6ab60c370f4d2fc5c02a5b19baf4410ace"}, + {file = "debugpy-1.8.1-cp312-cp312-win32.whl", hash = "sha256:caad2846e21188797a1f17fc09c31b84c7c3c23baf2516fed5b40b378515bbf0"}, + {file = "debugpy-1.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:edcc9f58ec0fd121a25bc950d4578df47428d72e1a0d66c07403b04eb93bcf98"}, + {file = "debugpy-1.8.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:7a3afa222f6fd3d9dfecd52729bc2e12c93e22a7491405a0ecbf9e1d32d45b39"}, + {file = "debugpy-1.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d915a18f0597ef685e88bb35e5d7ab968964b7befefe1aaea1eb5b2640b586c7"}, + {file = "debugpy-1.8.1-cp38-cp38-win32.whl", hash = "sha256:92116039b5500633cc8d44ecc187abe2dfa9b90f7a82bbf81d079fcdd506bae9"}, + {file = "debugpy-1.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:e38beb7992b5afd9d5244e96ad5fa9135e94993b0c551ceebf3fe1a5d9beb234"}, + {file = "debugpy-1.8.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:bfb20cb57486c8e4793d41996652e5a6a885b4d9175dd369045dad59eaacea42"}, + {file = "debugpy-1.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efd3fdd3f67a7e576dd869c184c5dd71d9aaa36ded271939da352880c012e703"}, + {file = "debugpy-1.8.1-cp39-cp39-win32.whl", hash = "sha256:58911e8521ca0c785ac7a0539f1e77e0ce2df753f786188f382229278b4cdf23"}, + {file = "debugpy-1.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:6df9aa9599eb05ca179fb0b810282255202a66835c6efb1d112d21ecb830ddd3"}, + {file = "debugpy-1.8.1-py2.py3-none-any.whl", hash = "sha256:28acbe2241222b87e255260c76741e1fbf04fdc3b6d094fcf57b6c6f75ce1242"}, + {file = "debugpy-1.8.1.zip", hash = "sha256:f696d6be15be87aef621917585f9bb94b1dc9e8aced570db1b8a6fc14e8f9b42"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.1" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"}, + {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "executing" +version = "2.0.1" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.5" +files = [ + {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, + {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + +[[package]] +name = "fastjsonschema" +version = "2.19.1" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, + {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + +[[package]] +name = "fonttools" +version = "4.51.0" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"}, + {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"}, + {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"}, + {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"}, + {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"}, + {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"}, + {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"}, + {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"}, + {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"}, + {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"}, + {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"}, + {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"}, + {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"}, + {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"}, + {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"}, + {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"}, + {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"}, + {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"}, + {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"}, + {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"}, + {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"}, + {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"}, + {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"}, + {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"}, + {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"}, + {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"}, + {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"}, + {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"}, + {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"}, + {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"}, + {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"}, + {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"}, + {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"}, + {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"}, + {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"}, + {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"}, + {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"}, + {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"}, + {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"}, + {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"}, + {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"}, + {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "pycairo", "scipy"] +lxml = ["lxml (>=4.0)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.1.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] + +[[package]] +name = "fqdn" +version = "1.5.1" +description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +optional = false +python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +optional = false +python-versions = ">=3.7" +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +description = "A minimal low-level HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[package.dependencies] +certifi = "*" +h11 = ">=0.13,<0.15" + +[package.extras] +asyncio = ["anyio (>=4.0,<5.0)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] +trio = ["trio (>=0.22.0,<0.26.0)"] + +[[package]] +name = "httpx" +version = "0.27.0" +description = "The next generation HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5"}, + {file = "httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5"}, +] + +[package.dependencies] +anyio = "*" +certifi = "*" +httpcore = "==1.*" +idna = "*" +sniffio = "*" + +[package.extras] +brotli = ["brotli", "brotlicffi"] +cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] + +[[package]] +name = "idna" +version = "3.7" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, + {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.4" +description = "IPython Kernel for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipykernel-6.29.4-py3-none-any.whl", hash = "sha256:1181e653d95c6808039c509ef8e67c4126b3b3af7781496c7cbfb5ed938a27da"}, + {file = "ipykernel-6.29.4.tar.gz", hash = "sha256:3d44070060f9475ac2092b760123fadf105d2e2493c24848b6691a7c4f42af5c"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.6.5" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=24" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] +pyqt5 = ["pyqt5"] +pyside6 = ["pyside6"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.23.5)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "ipython" +version = "8.23.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.10" +files = [ + {file = "ipython-8.23.0-py3-none-any.whl", hash = "sha256:07232af52a5ba146dc3372c7bf52a0f890a23edf38d77caef8d53f9cdc2584c1"}, + {file = "ipython-8.23.0.tar.gz", hash = "sha256:7468edaf4f6de3e1b912e57f66c241e6fd3c7099f2ec2136e239e142e800274d"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt-toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5.13.0" +typing-extensions = {version = "*", markers = "python_version < \"3.12\""} + +[package.extras] +all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"] +kernel = ["ipykernel"] +matplotlib = ["matplotlib"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] + +[[package]] +name = "ipywidgets" +version = "8.1.2" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.1.2-py3-none-any.whl", hash = "sha256:bbe43850d79fb5e906b14801d6c01402857996864d1e5b6fa62dd2ee35559f60"}, + {file = "ipywidgets-8.1.2.tar.gz", hash = "sha256:d0b9b41e49bae926a866e613a39b0f0097745d2b9f1f3dd406641b4a57ec42c9"}, +] + +[package.dependencies] +comm = ">=0.1.3" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.10,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.10,<4.1.0" + +[package.extras] +test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + +[[package]] +name = "isoduration" +version = "20.11.0" +description = "Operations with ISO 8601 durations" +optional = false +python-versions = ">=3.7" +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[package.dependencies] +arrow = ">=0.15.0" + +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + +[[package]] +name = "jinja2" +version = "3.1.3" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "Jinja2-3.1.3-py3-none-any.whl", hash = "sha256:7d6d50dd97d52cbc355597bd845fabfbac3f551e1f99619e39a35ce8c370b5fa"}, + {file = "Jinja2-3.1.3.tar.gz", hash = "sha256:ac8bd6544d4bb2c9792bf3a159e80bba8fda7f07e81bc3aed565432d5925ba90"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "json5" +version = "0.9.25" +description = "A Python implementation of the JSON5 data format." +optional = false +python-versions = ">=3.8" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "2.4" +description = "Identify specific nodes in a JSON document (RFC 6901)" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*" +files = [ + {file = "jsonpointer-2.4-py2.py3-none-any.whl", hash = "sha256:15d51bba20eea3165644553647711d150376234112651b4f1811022aecad7d7a"}, + {file = "jsonpointer-2.4.tar.gz", hash = "sha256:585cee82b70211fa9e6043b7bb89db6e1aa49524340dde8ad6b63206ea689d88"}, +] + +[[package]] +name = "jsonschema" +version = "4.21.1" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.21.1-py3-none-any.whl", hash = "sha256:7996507afae316306f9e2290407761157c6f78002dcf7419acb99822143d1c6f"}, + {file = "jsonschema-4.21.1.tar.gz", hash = "sha256:85727c00279f5fa6bedbe6238d2aa6403bedd8b4864ab11207d07df3cc1b2ee5"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} +rpds-py = ">=0.7.1" +uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +webcolors = {version = ">=1.11", optional = true, markers = "extra == \"format-nongpl\""} + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[package.dependencies] +referencing = ">=0.31.0" + +[[package]] +name = "jupyter" +version = "1.0.0" +description = "Jupyter metapackage. Install all the Jupyter components in one go." +optional = false +python-versions = "*" +files = [ + {file = "jupyter-1.0.0-py2.py3-none-any.whl", hash = "sha256:5b290f93b98ffbc21c0c7e749f054b3267782166d72fa5e3ed1ed4eaf34a2b78"}, + {file = "jupyter-1.0.0.tar.gz", hash = "sha256:d9dc4b3318f310e34c82951ea5d6683f67bed7def4b259fafbfe4f1beb1d8e5f"}, + {file = "jupyter-1.0.0.zip", hash = "sha256:3e1f86076bbb7c8c207829390305a2b1fe836d471ed54be66a3b8c41e7f46cc7"}, +] + +[package.dependencies] +ipykernel = "*" +ipywidgets = "*" +jupyter-console = "*" +nbconvert = "*" +notebook = "*" +qtconsole = "*" + +[[package]] +name = "jupyter-client" +version = "8.6.1" +description = "Jupyter protocol implementation and client libraries" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_client-8.6.1-py3-none-any.whl", hash = "sha256:3b7bd22f058434e3b9a7ea4b1500ed47de2713872288c0d511d19926f99b459f"}, + {file = "jupyter_client-8.6.1.tar.gz", hash = "sha256:e842515e2bab8e19186d89fdfea7abd15e39dd581f94e399f00e2af5a1652d3f"}, +] + +[package.dependencies] +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.2" +traitlets = ">=5.3" + +[package.extras] +docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +description = "Jupyter terminal console" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485"}, + {file = "jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539"}, +] + +[package.dependencies] +ipykernel = ">=6.14" +ipython = "*" +jupyter-client = ">=7.0.0" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +prompt-toolkit = ">=3.0.30" +pygments = "*" +pyzmq = ">=17" +traitlets = ">=5.4" + +[package.extras] +test = ["flaky", "pexpect", "pytest"] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = ">=5.3" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +description = "Jupyter Event System library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[package.dependencies] +jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]} +python-json-logger = ">=2.0.4" +pyyaml = ">=5.3" +referencing = "*" +rfc3339-validator = "*" +rfc3986-validator = ">=0.1.1" +traitlets = ">=5.3" + +[package.extras] +cli = ["click", "rich"] +docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] +test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[package.dependencies] +jupyter-server = ">=1.1.2" + +[[package]] +name = "jupyter-server" +version = "2.14.0" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server-2.14.0-py3-none-any.whl", hash = "sha256:fb6be52c713e80e004fac34b35a0990d6d36ba06fd0a2b2ed82b899143a64210"}, + {file = "jupyter_server-2.14.0.tar.gz", hash = "sha256:659154cea512083434fd7c93b7fe0897af7a2fd0b9dd4749282b42eaac4ae677"}, +] + +[package.dependencies] +anyio = ">=3.1.0" +argon2-cffi = ">=21.1" +jinja2 = ">=3.0.3" +jupyter-client = ">=7.4.4" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +jupyter-events = ">=0.9.0" +jupyter-server-terminals = ">=0.4.4" +nbconvert = ">=6.4.4" +nbformat = ">=5.3.0" +overrides = ">=5.0" +packaging = ">=22.0" +prometheus-client = ">=0.9" +pywinpty = {version = ">=2.0.1", markers = "os_name == \"nt\""} +pyzmq = ">=24" +send2trash = ">=1.8.2" +terminado = ">=0.8.3" +tornado = ">=6.2.0" +traitlets = ">=5.6.0" +websocket-client = ">=1.7" + +[package.extras] +docs = ["ipykernel", "jinja2", "jupyter-client", "jupyter-server", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] +test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0,<9)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.7)", "pytest-timeout", "requests"] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +description = "A Jupyter Server Extension Providing Terminals." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[package.dependencies] +pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} +terminado = ">=0.8.3" + +[package.extras] +docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] +test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] + +[[package]] +name = "jupyterlab" +version = "4.1.6" +description = "JupyterLab computational environment" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab-4.1.6-py3-none-any.whl", hash = "sha256:cf3e862bc10dbf4331e4eb37438634f813c238cfc62c71c640b3b3b2caa089a8"}, + {file = "jupyterlab-4.1.6.tar.gz", hash = "sha256:7935f36ba26eb615183a4f5c2bbca5791b5108ce2a00b5505f8cfd100d53648e"}, +] + +[package.dependencies] +async-lru = ">=1.0.0" +httpx = ">=0.25.0" +ipykernel = ">=6.5.0" +jinja2 = ">=3.0.3" +jupyter-core = "*" +jupyter-lsp = ">=2.0.0" +jupyter-server = ">=2.4.0,<3" +jupyterlab-server = ">=2.19.0,<3" +notebook-shim = ">=0.2" +packaging = "*" +tomli = {version = ">=1.2.2", markers = "python_version < \"3.11\""} +tornado = ">=6.2.0" +traitlets = "*" + +[package.extras] +dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.2.0)"] +docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<7.3.0)", "sphinx-copybutton"] +docs-screenshots = ["altair (==5.2.0)", "ipython (==8.16.1)", "ipywidgets (==8.1.1)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.0.post6)", "matplotlib (==3.8.2)", "nbconvert (>=7.0.0)", "pandas (==2.2.0)", "scipy (==1.12.0)", "vega-datasets (==0.9.0)"] +test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"] +upgrade-extension = ["copier (>=8.0,<9.0)", "jinja2-time (<0.3)", "pydantic (<2.0)", "pyyaml-include (<2.0)", "tomli-w (<2.0)"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.1" +description = "A set of server components for JupyterLab and JupyterLab like applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_server-2.27.1-py3-none-any.whl", hash = "sha256:f5e26156e5258b24d532c84e7c74cc212e203bff93eb856f81c24c16daeecc75"}, + {file = "jupyterlab_server-2.27.1.tar.gz", hash = "sha256:097b5ac709b676c7284ac9c5e373f11930a561f52cd5a86e4fc7e5a9c8a8631d"}, +] + +[package.dependencies] +babel = ">=2.10" +jinja2 = ">=3.0.3" +json5 = ">=0.9.0" +jsonschema = ">=4.18.0" +jupyter-server = ">=1.21,<3" +packaging = ">=21.3" +requests = ">=2.31" + +[package.extras] +docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] +openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] +test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0,<8)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.10" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.10-py3-none-any.whl", hash = "sha256:dd61f3ae7a5a7f80299e14585ce6cf3d6925a96c9103c978eda293197730cb64"}, + {file = "jupyterlab_widgets-3.0.10.tar.gz", hash = "sha256:04f2ac04976727e4f9d0fa91cdc2f1ab860f965e504c29dbd6a65c882c9d04c0"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.7" +files = [ + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.8.4" +description = "Python plotting package" +optional = false +python-versions = ">=3.9" +files = [ + {file = "matplotlib-3.8.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:abc9d838f93583650c35eca41cfcec65b2e7cb50fd486da6f0c49b5e1ed23014"}, + {file = "matplotlib-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f65c9f002d281a6e904976007b2d46a1ee2bcea3a68a8c12dda24709ddc9106"}, + {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce1edd9f5383b504dbc26eeea404ed0a00656c526638129028b758fd43fc5f10"}, + {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd79298550cba13a43c340581a3ec9c707bd895a6a061a78fa2524660482fc0"}, + {file = "matplotlib-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:90df07db7b599fe7035d2f74ab7e438b656528c68ba6bb59b7dc46af39ee48ef"}, + {file = "matplotlib-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:ac24233e8f2939ac4fd2919eed1e9c0871eac8057666070e94cbf0b33dd9c338"}, + {file = "matplotlib-3.8.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:72f9322712e4562e792b2961971891b9fbbb0e525011e09ea0d1f416c4645661"}, + {file = "matplotlib-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:232ce322bfd020a434caaffbd9a95333f7c2491e59cfc014041d95e38ab90d1c"}, + {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6addbd5b488aedb7f9bc19f91cd87ea476206f45d7116fcfe3d31416702a82fa"}, + {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc4ccdc64e3039fc303defd119658148f2349239871db72cd74e2eeaa9b80b71"}, + {file = "matplotlib-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b7a2a253d3b36d90c8993b4620183b55665a429da8357a4f621e78cd48b2b30b"}, + {file = "matplotlib-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:8080d5081a86e690d7688ffa542532e87f224c38a6ed71f8fbed34dd1d9fedae"}, + {file = "matplotlib-3.8.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6485ac1f2e84676cff22e693eaa4fbed50ef5dc37173ce1f023daef4687df616"}, + {file = "matplotlib-3.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c89ee9314ef48c72fe92ce55c4e95f2f39d70208f9f1d9db4e64079420d8d732"}, + {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50bac6e4d77e4262c4340d7a985c30912054745ec99756ce213bfbc3cb3808eb"}, + {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f51c4c869d4b60d769f7b4406eec39596648d9d70246428745a681c327a8ad30"}, + {file = "matplotlib-3.8.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b12ba985837e4899b762b81f5b2845bd1a28f4fdd1a126d9ace64e9c4eb2fb25"}, + {file = "matplotlib-3.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:7a6769f58ce51791b4cb8b4d7642489df347697cd3e23d88266aaaee93b41d9a"}, + {file = "matplotlib-3.8.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:843cbde2f0946dadd8c5c11c6d91847abd18ec76859dc319362a0964493f0ba6"}, + {file = "matplotlib-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c13f041a7178f9780fb61cc3a2b10423d5e125480e4be51beaf62b172413b67"}, + {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb44f53af0a62dc80bba4443d9b27f2fde6acfdac281d95bc872dc148a6509cc"}, + {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:606e3b90897554c989b1e38a258c626d46c873523de432b1462f295db13de6f9"}, + {file = "matplotlib-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9bb0189011785ea794ee827b68777db3ca3f93f3e339ea4d920315a0e5a78d54"}, + {file = "matplotlib-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:6209e5c9aaccc056e63b547a8152661324404dd92340a6e479b3a7f24b42a5d0"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7064120a59ce6f64103c9cefba8ffe6fba87f2c61d67c401186423c9a20fd35"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e47eda4eb2614300fc7bb4657fced3e83d6334d03da2173b09e447418d499f"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:493e9f6aa5819156b58fce42b296ea31969f2aab71c5b680b4ea7a3cb5c07d94"}, + {file = "matplotlib-3.8.4.tar.gz", hash = "sha256:8aac397d5e9ec158960e31c381c5ffc52ddd52bd9a47717e2a694038167dffea"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.3.1" +numpy = ">=1.21" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "mistune" +version = "3.0.2" +description = "A sane and fast Markdown parser with useful plugins and renderers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[package.dependencies] +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +nbformat = ">=5.1" +traitlets = ">=5.4" + +[package.extras] +dev = ["pre-commit"] +docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] +test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "7.16.3" +description = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbconvert-7.16.3-py3-none-any.whl", hash = "sha256:ddeff14beeeedf3dd0bc506623e41e4507e551736de59df69a91f86700292b3b"}, + {file = "nbconvert-7.16.3.tar.gz", hash = "sha256:a6733b78ce3d47c3f85e504998495b07e6ea9cf9bf6ec1c98dda63ec6ad19142"}, +] + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "!=5.0.0" +defusedxml = "*" +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +markupsafe = ">=2.0" +mistune = ">=2.0.3,<4" +nbclient = ">=0.5.0" +nbformat = ">=5.7" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.1" + +[package.extras] +all = ["nbconvert[docs,qtpdf,serve,test,webpdf]"] +docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] +qtpdf = ["nbconvert[qtpng]"] +qtpng = ["pyqtwebengine (>=5.15)"] +serve = ["tornado (>=6.1)"] +test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest (>=7)"] +webpdf = ["playwright"] + +[[package]] +name = "nbformat" +version = "5.10.4" +description = "The Jupyter Notebook format" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[package.dependencies] +fastjsonschema = ">=2.15" +jsonschema = ">=2.6" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +traitlets = ">=5.1" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["pep440", "pre-commit", "pytest", "testpath"] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +description = "Patch asyncio to allow nested event loops" +optional = false +python-versions = ">=3.5" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "notebook" +version = "7.1.3" +description = "Jupyter Notebook - A web-based notebook environment for interactive computing" +optional = false +python-versions = ">=3.8" +files = [ + {file = "notebook-7.1.3-py3-none-any.whl", hash = "sha256:919b911e59f41f6e3857ce93c9d93535ba66bb090059712770e5968c07e1004d"}, + {file = "notebook-7.1.3.tar.gz", hash = "sha256:41fcebff44cf7bb9377180808bcbae066629b55d8c7722f1ebbe75ca44f9cfc1"}, +] + +[package.dependencies] +jupyter-server = ">=2.4.0,<3" +jupyterlab = ">=4.1.1,<4.2" +jupyterlab-server = ">=2.22.1,<3" +notebook-shim = ">=0.2,<0.3" +tornado = ">=6.2.0" + +[package.extras] +dev = ["hatch", "pre-commit"] +docs = ["myst-parser", "nbsphinx", "pydata-sphinx-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +description = "A shim layer for notebook traits and config" +optional = false +python-versions = ">=3.7" +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[package.dependencies] +jupyter-server = ">=1.8,<3" + +[package.extras] +test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"] + +[[package]] +name = "numpy" +version = "1.26.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +description = "A decorator to automatically detect mismatch when overriding a method." +optional = false +python-versions = ">=3.6" +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.0" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, + {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +description = "Utilities for writing pandoc filters in python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[package.extras] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["docopt", "pytest"] + +[[package]] +name = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pillow" +version = "10.3.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, + {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, + {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, + {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, + {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, + {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, + {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, + {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, + {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, + {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, + {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, + {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, + {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, + {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, + {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, + {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, + {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] +typing = ["typing-extensions"] +xmp = ["defusedxml"] + +[[package]] +name = "platformdirs" +version = "4.2.0" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." +optional = false +python-versions = ">=3.8" +files = [ + {file = "platformdirs-4.2.0-py3-none-any.whl", hash = "sha256:0614df2a2f37e1a662acbd8e2b25b92ccf8632929bc6d43467e17fe89c75e068"}, + {file = "platformdirs-4.2.0.tar.gz", hash = "sha256:ef0cc731df711022c174543cb70a9b5bd22e5a9337c8624ef2c2ceb8ddad8768"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +description = "Python client for the Prometheus monitoring system." +optional = false +python-versions = ">=3.8" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[package.extras] +twisted = ["twisted"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.43" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, + {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "psutil" +version = "5.9.8" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +files = [ + {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, + {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, + {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, + {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, + {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, + {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, + {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, + {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, + {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, + {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, +] + +[package.extras] +test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + +[[package]] +name = "pycparser" +version = "2.22" +description = "C parser in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.7.0" +description = "Data validation using Python type hints" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic-2.7.0-py3-none-any.whl", hash = "sha256:9dee74a271705f14f9a1567671d144a851c675b072736f0a7b2608fd9e495352"}, + {file = "pydantic-2.7.0.tar.gz", hash = "sha256:b5ecdd42262ca2462e2624793551e80911a1e989f462910bb81aef974b4bb383"}, +] + +[package.dependencies] +annotated-types = ">=0.4.0" +pydantic-core = "2.18.1" +typing-extensions = ">=4.6.1" + +[package.extras] +email = ["email-validator (>=2.0.0)"] + +[[package]] +name = "pydantic-core" +version = "2.18.1" +description = "Core functionality for Pydantic validation and serialization" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic_core-2.18.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ee9cf33e7fe14243f5ca6977658eb7d1042caaa66847daacbd2117adb258b226"}, + {file = "pydantic_core-2.18.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6b7bbb97d82659ac8b37450c60ff2e9f97e4eb0f8a8a3645a5568b9334b08b50"}, + {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df4249b579e75094f7e9bb4bd28231acf55e308bf686b952f43100a5a0be394c"}, + {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d0491006a6ad20507aec2be72e7831a42efc93193d2402018007ff827dc62926"}, + {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ae80f72bb7a3e397ab37b53a2b49c62cc5496412e71bc4f1277620a7ce3f52b"}, + {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:58aca931bef83217fca7a390e0486ae327c4af9c3e941adb75f8772f8eeb03a1"}, + {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1be91ad664fc9245404a789d60cba1e91c26b1454ba136d2a1bf0c2ac0c0505a"}, + {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:667880321e916a8920ef49f5d50e7983792cf59f3b6079f3c9dac2b88a311d17"}, + {file = "pydantic_core-2.18.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f7054fdc556f5421f01e39cbb767d5ec5c1139ea98c3e5b350e02e62201740c7"}, + {file = "pydantic_core-2.18.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:030e4f9516f9947f38179249778709a460a3adb516bf39b5eb9066fcfe43d0e6"}, + {file = "pydantic_core-2.18.1-cp310-none-win32.whl", hash = "sha256:2e91711e36e229978d92642bfc3546333a9127ecebb3f2761372e096395fc649"}, + {file = "pydantic_core-2.18.1-cp310-none-win_amd64.whl", hash = "sha256:9a29726f91c6cb390b3c2338f0df5cd3e216ad7a938762d11c994bb37552edb0"}, + {file = "pydantic_core-2.18.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9ece8a49696669d483d206b4474c367852c44815fca23ac4e48b72b339807f80"}, + {file = "pydantic_core-2.18.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a5d83efc109ceddb99abd2c1316298ced2adb4570410defe766851a804fcd5b"}, + {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f7973c381283783cd1043a8c8f61ea5ce7a3a58b0369f0ee0ee975eaf2f2a1b"}, + {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:54c7375c62190a7845091f521add19b0f026bcf6ae674bdb89f296972272e86d"}, + {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd63cec4e26e790b70544ae5cc48d11b515b09e05fdd5eff12e3195f54b8a586"}, + {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:561cf62c8a3498406495cfc49eee086ed2bb186d08bcc65812b75fda42c38294"}, + {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68717c38a68e37af87c4da20e08f3e27d7e4212e99e96c3d875fbf3f4812abfc"}, + {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2d5728e93d28a3c63ee513d9ffbac9c5989de8c76e049dbcb5bfe4b923a9739d"}, + {file = "pydantic_core-2.18.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f0f17814c505f07806e22b28856c59ac80cee7dd0fbb152aed273e116378f519"}, + {file = "pydantic_core-2.18.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d816f44a51ba5175394bc6c7879ca0bd2be560b2c9e9f3411ef3a4cbe644c2e9"}, + {file = "pydantic_core-2.18.1-cp311-none-win32.whl", hash = "sha256:09f03dfc0ef8c22622eaa8608caa4a1e189cfb83ce847045eca34f690895eccb"}, + {file = "pydantic_core-2.18.1-cp311-none-win_amd64.whl", hash = "sha256:27f1009dc292f3b7ca77feb3571c537276b9aad5dd4efb471ac88a8bd09024e9"}, + {file = "pydantic_core-2.18.1-cp311-none-win_arm64.whl", hash = "sha256:48dd883db92e92519201f2b01cafa881e5f7125666141a49ffba8b9facc072b0"}, + {file = "pydantic_core-2.18.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b6b0e4912030c6f28bcb72b9ebe4989d6dc2eebcd2a9cdc35fefc38052dd4fe8"}, + {file = "pydantic_core-2.18.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3202a429fe825b699c57892d4371c74cc3456d8d71b7f35d6028c96dfecad31"}, + {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3982b0a32d0a88b3907e4b0dc36809fda477f0757c59a505d4e9b455f384b8b"}, + {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25595ac311f20e5324d1941909b0d12933f1fd2171075fcff763e90f43e92a0d"}, + {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:14fe73881cf8e4cbdaded8ca0aa671635b597e42447fec7060d0868b52d074e6"}, + {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ca976884ce34070799e4dfc6fbd68cb1d181db1eefe4a3a94798ddfb34b8867f"}, + {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:684d840d2c9ec5de9cb397fcb3f36d5ebb6fa0d94734f9886032dd796c1ead06"}, + {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:54764c083bbe0264f0f746cefcded6cb08fbbaaf1ad1d78fb8a4c30cff999a90"}, + {file = "pydantic_core-2.18.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:201713f2f462e5c015b343e86e68bd8a530a4f76609b33d8f0ec65d2b921712a"}, + {file = "pydantic_core-2.18.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fd1a9edb9dd9d79fbeac1ea1f9a8dd527a6113b18d2e9bcc0d541d308dae639b"}, + {file = "pydantic_core-2.18.1-cp312-none-win32.whl", hash = "sha256:d5e6b7155b8197b329dc787356cfd2684c9d6a6b1a197f6bbf45f5555a98d411"}, + {file = "pydantic_core-2.18.1-cp312-none-win_amd64.whl", hash = "sha256:9376d83d686ec62e8b19c0ac3bf8d28d8a5981d0df290196fb6ef24d8a26f0d6"}, + {file = "pydantic_core-2.18.1-cp312-none-win_arm64.whl", hash = "sha256:c562b49c96906b4029b5685075fe1ebd3b5cc2601dfa0b9e16c2c09d6cbce048"}, + {file = "pydantic_core-2.18.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:3e352f0191d99fe617371096845070dee295444979efb8f27ad941227de6ad09"}, + {file = "pydantic_core-2.18.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c0295d52b012cbe0d3059b1dba99159c3be55e632aae1999ab74ae2bd86a33d7"}, + {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56823a92075780582d1ffd4489a2e61d56fd3ebb4b40b713d63f96dd92d28144"}, + {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dd3f79e17b56741b5177bcc36307750d50ea0698df6aa82f69c7db32d968c1c2"}, + {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38a5024de321d672a132b1834a66eeb7931959c59964b777e8f32dbe9523f6b1"}, + {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d2ce426ee691319d4767748c8e0895cfc56593d725594e415f274059bcf3cb76"}, + {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2adaeea59849ec0939af5c5d476935f2bab4b7f0335b0110f0f069a41024278e"}, + {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9b6431559676a1079eac0f52d6d0721fb8e3c5ba43c37bc537c8c83724031feb"}, + {file = "pydantic_core-2.18.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:85233abb44bc18d16e72dc05bf13848a36f363f83757541f1a97db2f8d58cfd9"}, + {file = "pydantic_core-2.18.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:641a018af4fe48be57a2b3d7a1f0f5dbca07c1d00951d3d7463f0ac9dac66622"}, + {file = "pydantic_core-2.18.1-cp38-none-win32.whl", hash = "sha256:63d7523cd95d2fde0d28dc42968ac731b5bb1e516cc56b93a50ab293f4daeaad"}, + {file = "pydantic_core-2.18.1-cp38-none-win_amd64.whl", hash = "sha256:907a4d7720abfcb1c81619863efd47c8a85d26a257a2dbebdb87c3b847df0278"}, + {file = "pydantic_core-2.18.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:aad17e462f42ddbef5984d70c40bfc4146c322a2da79715932cd8976317054de"}, + {file = "pydantic_core-2.18.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:94b9769ba435b598b547c762184bcfc4783d0d4c7771b04a3b45775c3589ca44"}, + {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:80e0e57cc704a52fb1b48f16d5b2c8818da087dbee6f98d9bf19546930dc64b5"}, + {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:76b86e24039c35280ceee6dce7e62945eb93a5175d43689ba98360ab31eebc4a"}, + {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12a05db5013ec0ca4a32cc6433f53faa2a014ec364031408540ba858c2172bb0"}, + {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:250ae39445cb5475e483a36b1061af1bc233de3e9ad0f4f76a71b66231b07f88"}, + {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a32204489259786a923e02990249c65b0f17235073149d0033efcebe80095570"}, + {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6395a4435fa26519fd96fdccb77e9d00ddae9dd6c742309bd0b5610609ad7fb2"}, + {file = "pydantic_core-2.18.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2533ad2883f001efa72f3d0e733fb846710c3af6dcdd544fe5bf14fa5fe2d7db"}, + {file = "pydantic_core-2.18.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b560b72ed4816aee52783c66854d96157fd8175631f01ef58e894cc57c84f0f6"}, + {file = "pydantic_core-2.18.1-cp39-none-win32.whl", hash = "sha256:582cf2cead97c9e382a7f4d3b744cf0ef1a6e815e44d3aa81af3ad98762f5a9b"}, + {file = "pydantic_core-2.18.1-cp39-none-win_amd64.whl", hash = "sha256:ca71d501629d1fa50ea7fa3b08ba884fe10cefc559f5c6c8dfe9036c16e8ae89"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e178e5b66a06ec5bf51668ec0d4ac8cfb2bdcb553b2c207d58148340efd00143"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:72722ce529a76a4637a60be18bd789d8fb871e84472490ed7ddff62d5fed620d"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fe0c1ce5b129455e43f941f7a46f61f3d3861e571f2905d55cdbb8b5c6f5e2c"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4284c621f06a72ce2cb55f74ea3150113d926a6eb78ab38340c08f770eb9b4d"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a0c3e718f4e064efde68092d9d974e39572c14e56726ecfaeebbe6544521f47"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:2027493cc44c23b598cfaf200936110433d9caa84e2c6cf487a83999638a96ac"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:76909849d1a6bffa5a07742294f3fa1d357dc917cb1fe7b470afbc3a7579d539"}, + {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ee7ccc7fb7e921d767f853b47814c3048c7de536663e82fbc37f5eb0d532224b"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ee2794111c188548a4547eccc73a6a8527fe2af6cf25e1a4ebda2fd01cdd2e60"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a139fe9f298dc097349fb4f28c8b81cc7a202dbfba66af0e14be5cfca4ef7ce5"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d074b07a10c391fc5bbdcb37b2f16f20fcd9e51e10d01652ab298c0d07908ee2"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c69567ddbac186e8c0aadc1f324a60a564cfe25e43ef2ce81bcc4b8c3abffbae"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:baf1c7b78cddb5af00971ad5294a4583188bda1495b13760d9f03c9483bb6203"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:2684a94fdfd1b146ff10689c6e4e815f6a01141781c493b97342cdc5b06f4d5d"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:73c1bc8a86a5c9e8721a088df234265317692d0b5cd9e86e975ce3bc3db62a59"}, + {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e60defc3c15defb70bb38dd605ff7e0fae5f6c9c7cbfe0ad7868582cb7e844a6"}, + {file = "pydantic_core-2.18.1.tar.gz", hash = "sha256:de9d3e8717560eb05e28739d1b35e4eac2e458553a52a301e51352a7ffc86a35"}, +] + +[package.dependencies] +typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" + +[[package]] +name = "pygments" +version = "2.17.2" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, + {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, +] + +[package.extras] +plugins = ["importlib-metadata"] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pyparsing" +version = "3.1.2" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"}, + {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "python-json-logger" +version = "2.0.7" +description = "A python library adding a json log formatter" +optional = false +python-versions = ">=3.6" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pywin32" +version = "306" +description = "Python for Window Extensions" +optional = false +python-versions = "*" +files = [ + {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, + {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, + {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, + {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, + {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, + {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pywinpty" +version = "2.0.13" +description = "Pseudo terminal support for Windows from Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"}, + {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"}, + {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"}, + {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"}, + {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"}, + {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.1" +description = "YAML parser and emitter for Python" +optional = false +python-versions = ">=3.6" +files = [ + {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, + {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, + {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, + {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, + {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, + {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, + {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, + {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, + {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, + {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, + {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, + {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, + {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, +] + +[[package]] +name = "pyzmq" +version = "26.0.2" +description = "Python bindings for 0MQ" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pyzmq-26.0.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:1a60a03b01e8c9c58932ec0cca15b1712d911c2800eb82d4281bc1ae5b6dad50"}, + {file = "pyzmq-26.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:949067079e14ea1973bd740255e0840118c163d4bce8837f539d749f145cf5c3"}, + {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37e7edfa6cf96d036a403775c96afa25058d1bb940a79786a9a2fc94a783abe3"}, + {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:903cc7a84a7d4326b43755c368780800e035aa3d711deae84a533fdffa8755b0"}, + {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6cb2e41af165e5f327d06fbdd79a42a4e930267fade4e9f92d17f3ccce03f3a7"}, + {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:55353b8189adcfc4c125fc4ce59d477744118e9c0ec379dd0999c5fa120ac4f5"}, + {file = "pyzmq-26.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f961423ff6236a752ced80057a20e623044df95924ed1009f844cde8b3a595f9"}, + {file = "pyzmq-26.0.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ba77fe84fe4f5f3dc0ef681a6d366685c8ffe1c8439c1d7530997b05ac06a04b"}, + {file = "pyzmq-26.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:52589f0a745ef61b9c75c872cf91f8c1f7c0668eb3dd99d7abd639d8c0fb9ca7"}, + {file = "pyzmq-26.0.2-cp310-cp310-win32.whl", hash = "sha256:b7b6d2a46c7afe2ad03ec8faf9967090c8ceae85c4d8934d17d7cae6f9062b64"}, + {file = "pyzmq-26.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:86531e20de249d9204cc6d8b13d5a30537748c78820215161d8a3b9ea58ca111"}, + {file = "pyzmq-26.0.2-cp310-cp310-win_arm64.whl", hash = "sha256:f26a05029ecd2bd306b941ff8cb80f7620b7901421052bc429d238305b1cbf2f"}, + {file = "pyzmq-26.0.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:70770e296a9cb03d955540c99360aab861cbb3cba29516abbd106a15dbd91268"}, + {file = "pyzmq-26.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2740fd7161b39e178554ebf21aa5667a1c9ef0cd2cb74298fd4ef017dae7aec4"}, + {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5e3706c32dea077faa42b1c92d825b7f86c866f72532d342e0be5e64d14d858"}, + {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0fa1416876194927f7723d6b7171b95e1115602967fc6bfccbc0d2d51d8ebae1"}, + {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ef9a79a48794099c57dc2df00340b5d47c5caa1792f9ddb8c7a26b1280bd575"}, + {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1c60fcdfa3229aeee4291c5d60faed3a813b18bdadb86299c4bf49e8e51e8605"}, + {file = "pyzmq-26.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e943c39c206b04df2eb5d71305761d7c3ca75fd49452115ea92db1b5b98dbdef"}, + {file = "pyzmq-26.0.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:8da0ed8a598693731c76659880a668f4748b59158f26ed283a93f7f04d47447e"}, + {file = "pyzmq-26.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7bf51970b11d67096bede97cdbad0f4333f7664f4708b9b2acb352bf4faa3140"}, + {file = "pyzmq-26.0.2-cp311-cp311-win32.whl", hash = "sha256:6f8e6bd5d066be605faa9fe5ec10aa1a46ad9f18fc8646f2b9aaefc8fb575742"}, + {file = "pyzmq-26.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:6d03da3a0ae691b361edcb39530075461202f699ce05adbb15055a0e1c9bcaa4"}, + {file = "pyzmq-26.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:f84e33321b68ff00b60e9dbd1a483e31ab6022c577c8de525b8e771bd274ce68"}, + {file = "pyzmq-26.0.2-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:44c33ebd1c62a01db7fbc24e18bdda569d6639217d13d5929e986a2b0f69070d"}, + {file = "pyzmq-26.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ac04f904b4fce4afea9cdccbb78e24d468cb610a839d5a698853e14e2a3f9ecf"}, + {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2133de5ba9adc5f481884ccb699eac9ce789708292945c05746880f95b241c0"}, + {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7753c67c570d7fc80c2dc59b90ca1196f1224e0e2e29a548980c95fe0fe27fc1"}, + {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d4e51632e6b12e65e8d9d7612446ecda2eda637a868afa7bce16270194650dd"}, + {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d6c38806f6ecd0acf3104b8d7e76a206bcf56dadd6ce03720d2fa9d9157d5718"}, + {file = "pyzmq-26.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:48f496bbe14686b51cec15406323ae6942851e14022efd7fc0e2ecd092c5982c"}, + {file = "pyzmq-26.0.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e84a3161149c75bb7a7dc8646384186c34033e286a67fec1ad1bdedea165e7f4"}, + {file = "pyzmq-26.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:dabf796c67aa9f5a4fcc956d47f0d48b5c1ed288d628cf53aa1cf08e88654343"}, + {file = "pyzmq-26.0.2-cp312-cp312-win32.whl", hash = "sha256:3eee4c676af1b109f708d80ef0cf57ecb8aaa5900d1edaf90406aea7e0e20e37"}, + {file = "pyzmq-26.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:26721fec65846b3e4450dad050d67d31b017f97e67f7e0647b5f98aa47f828cf"}, + {file = "pyzmq-26.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:653955c6c233e90de128a1b8e882abc7216f41f44218056bd519969c8c413a15"}, + {file = "pyzmq-26.0.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:becd8d8fb068fbb5a52096efd83a2d8e54354383f691781f53a4c26aee944542"}, + {file = "pyzmq-26.0.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:7a15e5465e7083c12517209c9dd24722b25e9b63c49a563922922fc03554eb35"}, + {file = "pyzmq-26.0.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e8158ac8616941f874841f9fa0f6d2f1466178c2ff91ea08353fdc19de0d40c2"}, + {file = "pyzmq-26.0.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea2c6a53e28c7066ea7db86fcc0b71d78d01b818bb11d4a4341ec35059885295"}, + {file = "pyzmq-26.0.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:bdbc7dab0b0e9c62c97b732899c4242e3282ba803bad668e03650b59b165466e"}, + {file = "pyzmq-26.0.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:e74b6d5ef57bb65bf1b4a37453d8d86d88550dde3fb0f23b1f1a24e60c70af5b"}, + {file = "pyzmq-26.0.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ed4c6ee624ecbc77b18aeeb07bf0700d26571ab95b8f723f0d02e056b5bce438"}, + {file = "pyzmq-26.0.2-cp37-cp37m-win32.whl", hash = "sha256:8a98b3cb0484b83c19d8fb5524c8a469cd9f10e743f5904ac285d92678ee761f"}, + {file = "pyzmq-26.0.2-cp37-cp37m-win_amd64.whl", hash = "sha256:aa5f95d71b6eca9cec28aa0a2f8310ea53dea313b63db74932879ff860c1fb8d"}, + {file = "pyzmq-26.0.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:5ff56c76ce77b9805378a7a73032c17cbdb1a5b84faa1df03c5d3e306e5616df"}, + {file = "pyzmq-26.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bab697fc1574fee4b81da955678708567c43c813c84c91074e452bda5346c921"}, + {file = "pyzmq-26.0.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0c0fed8aa9ba0488ee1cbdaa304deea92d52fab43d373297002cfcc69c0a20c5"}, + {file = "pyzmq-26.0.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:606b922699fcec472ed814dda4dc3ff7c748254e0b26762a0ba21a726eb1c107"}, + {file = "pyzmq-26.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45f0fd82bad4d199fa993fbf0ac586a7ac5879addbe436a35a389df7e0eb4c91"}, + {file = "pyzmq-26.0.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:166c5e41045939a52c01e6f374e493d9a6a45dfe677360d3e7026e38c42e8906"}, + {file = "pyzmq-26.0.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:d566e859e8b8d5bca08467c093061774924b3d78a5ba290e82735b2569edc84b"}, + {file = "pyzmq-26.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:264ee0e72b72ca59279dc320deab5ae0fac0d97881aed1875ce4bde2e56ffde0"}, + {file = "pyzmq-26.0.2-cp38-cp38-win32.whl", hash = "sha256:3152bbd3a4744cbdd83dfb210ed701838b8b0c9065cef14671d6d91df12197d0"}, + {file = "pyzmq-26.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:bf77601d75ca692c179154b7e5943c286a4aaffec02c491afe05e60493ce95f2"}, + {file = "pyzmq-26.0.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:c770a7545b3deca2db185b59175e710a820dd4ed43619f4c02e90b0e227c6252"}, + {file = "pyzmq-26.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d47175f0a380bfd051726bc5c0054036ae4a5d8caf922c62c8a172ccd95c1a2a"}, + {file = "pyzmq-26.0.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9bce298c1ce077837e110367c321285dc4246b531cde1abfc27e4a5bbe2bed4d"}, + {file = "pyzmq-26.0.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c40b09b7e184d6e3e1be1c8af2cc320c0f9f610d8a5df3dd866e6e6e4e32b235"}, + {file = "pyzmq-26.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d420d856bf728713874cefb911398efe69e1577835851dd297a308a78c14c249"}, + {file = "pyzmq-26.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d792d3cab987058451e55c70c5926e93e2ceb68ca5a2334863bb903eb860c9cb"}, + {file = "pyzmq-26.0.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:83ec17729cf6d3464dab98a11e98294fcd50e6b17eaabd3d841515c23f6dbd3a"}, + {file = "pyzmq-26.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47c17d5ebfa88ae90f08960c97b49917098665b8cd8be31f2c24e177bcf37a0f"}, + {file = "pyzmq-26.0.2-cp39-cp39-win32.whl", hash = "sha256:d509685d1cd1d018705a811c5f9d5bc237790936ead6d06f6558b77e16cc7235"}, + {file = "pyzmq-26.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:c7cc8cc009e8f6989a6d86c96f87dae5f5fb07d6c96916cdc7719d546152c7db"}, + {file = "pyzmq-26.0.2-cp39-cp39-win_arm64.whl", hash = "sha256:3ada31cb879cd7532f4a85b501f4255c747d4813ab76b35c49ed510ce4865b45"}, + {file = "pyzmq-26.0.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0a6ceaddc830dd3ca86cb8451cf373d1f05215368e11834538c2902ed5205139"}, + {file = "pyzmq-26.0.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a967681463aa7a99eb9a62bb18229b653b45c10ff0947b31cc0837a83dfb86f"}, + {file = "pyzmq-26.0.2-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6472a73bc115bc40a2076609a90894775abe6faf19a78375675a2f889a613071"}, + {file = "pyzmq-26.0.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d6aea92bcccfe5e5524d3c70a6f16ffdae548390ddad26f4207d55c55a40593"}, + {file = "pyzmq-26.0.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e025f6351e49d48a5aa2f5a09293aa769b0ee7369c25bed551647234b7fa0c75"}, + {file = "pyzmq-26.0.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:40bd7ebe4dbb37d27f0c56e2a844f360239343a99be422085e13e97da13f73f9"}, + {file = "pyzmq-26.0.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1dd40d586ad6f53764104df6e01810fe1b4e88fd353774629a5e6fe253813f79"}, + {file = "pyzmq-26.0.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f2aca15e9ad8c8657b5b3d7ae3d1724dc8c1c1059c06b4b674c3aa36305f4930"}, + {file = "pyzmq-26.0.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:450ec234736732eb0ebeffdb95a352450d4592f12c3e087e2a9183386d22c8bf"}, + {file = "pyzmq-26.0.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:f43be2bebbd09360a2f23af83b243dc25ffe7b583ea8c722e6df03e03a55f02f"}, + {file = "pyzmq-26.0.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:867f55e54aff254940bcec5eec068e7c0ac1e6bf360ab91479394a8bf356b0e6"}, + {file = "pyzmq-26.0.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b4dbc033c5ad46f8c429bf238c25a889b8c1d86bfe23a74e1031a991cb3f0000"}, + {file = "pyzmq-26.0.2-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6e8dd2961462e337e21092ec2da0c69d814dcb1b6e892955a37444a425e9cfb8"}, + {file = "pyzmq-26.0.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35391e72df6c14a09b697c7b94384947c1dd326aca883ff98ff137acdf586c33"}, + {file = "pyzmq-26.0.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:1c3d3c92fa54eda94ab369ca5b8d35059987c326ba5e55326eb068862f64b1fc"}, + {file = "pyzmq-26.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e7aa61a9cc4f0523373e31fc9255bf4567185a099f85ca3598e64de484da3ab2"}, + {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee53a8191271f144cc20b12c19daa9f1546adc84a2f33839e3338039b55c373c"}, + {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac60a980f07fa988983f7bfe6404ef3f1e4303f5288a01713bc1266df6d18783"}, + {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88896b1b4817d7b2fe1ec7205c4bbe07bf5d92fb249bf2d226ddea8761996068"}, + {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:18dfffe23751edee917764ffa133d5d3fef28dfd1cf3adebef8c90bc854c74c4"}, + {file = "pyzmq-26.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:6926dd14cfe6967d3322640b6d5c3c3039db71716a5e43cca6e3b474e73e0b36"}, + {file = "pyzmq-26.0.2.tar.gz", hash = "sha256:f0f9bb370449158359bb72a3e12c658327670c0ffe6fbcd1af083152b64f9df0"}, +] + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} + +[[package]] +name = "qtconsole" +version = "5.5.1" +description = "Jupyter Qt console" +optional = false +python-versions = ">= 3.8" +files = [ + {file = "qtconsole-5.5.1-py3-none-any.whl", hash = "sha256:8c75fa3e9b4ed884880ff7cea90a1b67451219279ec33deaee1d59e3df1a5d2b"}, + {file = "qtconsole-5.5.1.tar.gz", hash = "sha256:a0e806c6951db9490628e4df80caec9669b65149c7ba40f9bf033c025a5b56bc"}, +] + +[package.dependencies] +ipykernel = ">=4.1" +jupyter-client = ">=4.1" +jupyter-core = "*" +packaging = "*" +pygments = "*" +pyzmq = ">=17.1" +qtpy = ">=2.4.0" +traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2" + +[package.extras] +doc = ["Sphinx (>=1.3)"] +test = ["flaky", "pytest", "pytest-qt"] + +[[package]] +name = "qtpy" +version = "2.4.1" +description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +optional = false +python-versions = ">=3.7" +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[package.dependencies] +packaging = "*" + +[package.extras] +test = ["pytest (>=6,!=7.0.0,!=7.0.1)", "pytest-cov (>=3.0.0)", "pytest-qt"] + +[[package]] +name = "referencing" +version = "0.34.0" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.34.0-py3-none-any.whl", hash = "sha256:d53ae300ceddd3169f1ffa9caf2cb7b769e92657e4fafb23d34b93679116dfd4"}, + {file = "referencing-0.34.0.tar.gz", hash = "sha256:5773bd84ef41799a5a8ca72dc34590c041eb01bf9aa02632b4a973fb0181a844"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + +[[package]] +name = "requests" +version = "2.31.0" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.7" +files = [ + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +description = "A pure python RFC3339 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[package.dependencies] +six = "*" + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +description = "Pure python rfc3986 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rpds-py" +version = "0.18.0" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.18.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:5b4e7d8d6c9b2e8ee2d55c90b59c707ca59bc30058269b3db7b1f8df5763557e"}, + {file = "rpds_py-0.18.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c463ed05f9dfb9baebef68048aed8dcdc94411e4bf3d33a39ba97e271624f8f7"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01e36a39af54a30f28b73096dd39b6802eddd04c90dbe161c1b8dbe22353189f"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d62dec4976954a23d7f91f2f4530852b0c7608116c257833922a896101336c51"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd18772815d5f008fa03d2b9a681ae38d5ae9f0e599f7dda233c439fcaa00d40"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:923d39efa3cfb7279a0327e337a7958bff00cc447fd07a25cddb0a1cc9a6d2da"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39514da80f971362f9267c600b6d459bfbbc549cffc2cef8e47474fddc9b45b1"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a34d557a42aa28bd5c48a023c570219ba2593bcbbb8dc1b98d8cf5d529ab1434"}, + {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:93df1de2f7f7239dc9cc5a4a12408ee1598725036bd2dedadc14d94525192fc3"}, + {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:34b18ba135c687f4dac449aa5157d36e2cbb7c03cbea4ddbd88604e076aa836e"}, + {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c0b5dcf9193625afd8ecc92312d6ed78781c46ecbf39af9ad4681fc9f464af88"}, + {file = "rpds_py-0.18.0-cp310-none-win32.whl", hash = "sha256:c4325ff0442a12113a6379af66978c3fe562f846763287ef66bdc1d57925d337"}, + {file = "rpds_py-0.18.0-cp310-none-win_amd64.whl", hash = "sha256:7223a2a5fe0d217e60a60cdae28d6949140dde9c3bcc714063c5b463065e3d66"}, + {file = "rpds_py-0.18.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3a96e0c6a41dcdba3a0a581bbf6c44bb863f27c541547fb4b9711fd8cf0ffad4"}, + {file = "rpds_py-0.18.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30f43887bbae0d49113cbaab729a112251a940e9b274536613097ab8b4899cf6"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fcb25daa9219b4cf3a0ab24b0eb9a5cc8949ed4dc72acb8fa16b7e1681aa3c58"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d68c93e381010662ab873fea609bf6c0f428b6d0bb00f2c6939782e0818d37bf"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b34b7aa8b261c1dbf7720b5d6f01f38243e9b9daf7e6b8bc1fd4657000062f2c"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2e6d75ab12b0bbab7215e5d40f1e5b738aa539598db27ef83b2ec46747df90e1"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b8612cd233543a3781bc659c731b9d607de65890085098986dfd573fc2befe5"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aec493917dd45e3c69d00a8874e7cbed844efd935595ef78a0f25f14312e33c6"}, + {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:661d25cbffaf8cc42e971dd570d87cb29a665f49f4abe1f9e76be9a5182c4688"}, + {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1df3659d26f539ac74fb3b0c481cdf9d725386e3552c6fa2974f4d33d78e544b"}, + {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a1ce3ba137ed54f83e56fb983a5859a27d43a40188ba798993812fed73c70836"}, + {file = "rpds_py-0.18.0-cp311-none-win32.whl", hash = "sha256:69e64831e22a6b377772e7fb337533c365085b31619005802a79242fee620bc1"}, + {file = "rpds_py-0.18.0-cp311-none-win_amd64.whl", hash = "sha256:998e33ad22dc7ec7e030b3df701c43630b5bc0d8fbc2267653577e3fec279afa"}, + {file = "rpds_py-0.18.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:7f2facbd386dd60cbbf1a794181e6aa0bd429bd78bfdf775436020172e2a23f0"}, + {file = "rpds_py-0.18.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1d9a5be316c15ffb2b3c405c4ff14448c36b4435be062a7f578ccd8b01f0c4d8"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cd5bf1af8efe569654bbef5a3e0a56eca45f87cfcffab31dd8dde70da5982475"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5417558f6887e9b6b65b4527232553c139b57ec42c64570569b155262ac0754f"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:56a737287efecafc16f6d067c2ea0117abadcd078d58721f967952db329a3e5c"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8f03bccbd8586e9dd37219bce4d4e0d3ab492e6b3b533e973fa08a112cb2ffc9"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4457a94da0d5c53dc4b3e4de1158bdab077db23c53232f37a3cb7afdb053a4e3"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0ab39c1ba9023914297dd88ec3b3b3c3f33671baeb6acf82ad7ce883f6e8e157"}, + {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d54553c1136b50fd12cc17e5b11ad07374c316df307e4cfd6441bea5fb68496"}, + {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0af039631b6de0397ab2ba16eaf2872e9f8fca391b44d3d8cac317860a700a3f"}, + {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:84ffab12db93b5f6bad84c712c92060a2d321b35c3c9960b43d08d0f639d60d7"}, + {file = "rpds_py-0.18.0-cp312-none-win32.whl", hash = "sha256:685537e07897f173abcf67258bee3c05c374fa6fff89d4c7e42fb391b0605e98"}, + {file = "rpds_py-0.18.0-cp312-none-win_amd64.whl", hash = "sha256:e003b002ec72c8d5a3e3da2989c7d6065b47d9eaa70cd8808b5384fbb970f4ec"}, + {file = "rpds_py-0.18.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:08f9ad53c3f31dfb4baa00da22f1e862900f45908383c062c27628754af2e88e"}, + {file = "rpds_py-0.18.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c0013fe6b46aa496a6749c77e00a3eb07952832ad6166bd481c74bda0dcb6d58"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e32a92116d4f2a80b629778280103d2a510a5b3f6314ceccd6e38006b5e92dcb"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e541ec6f2ec456934fd279a3120f856cd0aedd209fc3852eca563f81738f6861"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bed88b9a458e354014d662d47e7a5baafd7ff81c780fd91584a10d6ec842cb73"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2644e47de560eb7bd55c20fc59f6daa04682655c58d08185a9b95c1970fa1e07"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e8916ae4c720529e18afa0b879473049e95949bf97042e938530e072fde061d"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:465a3eb5659338cf2a9243e50ad9b2296fa15061736d6e26240e713522b6235c"}, + {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ea7d4a99f3b38c37eac212dbd6ec42b7a5ec51e2c74b5d3223e43c811609e65f"}, + {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:67071a6171e92b6da534b8ae326505f7c18022c6f19072a81dcf40db2638767c"}, + {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:41ef53e7c58aa4ef281da975f62c258950f54b76ec8e45941e93a3d1d8580594"}, + {file = "rpds_py-0.18.0-cp38-none-win32.whl", hash = "sha256:fdea4952db2793c4ad0bdccd27c1d8fdd1423a92f04598bc39425bcc2b8ee46e"}, + {file = "rpds_py-0.18.0-cp38-none-win_amd64.whl", hash = "sha256:7cd863afe7336c62ec78d7d1349a2f34c007a3cc6c2369d667c65aeec412a5b1"}, + {file = "rpds_py-0.18.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:5307def11a35f5ae4581a0b658b0af8178c65c530e94893345bebf41cc139d33"}, + {file = "rpds_py-0.18.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:77f195baa60a54ef9d2de16fbbfd3ff8b04edc0c0140a761b56c267ac11aa467"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39f5441553f1c2aed4de4377178ad8ff8f9d733723d6c66d983d75341de265ab"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a00312dea9310d4cb7dbd7787e722d2e86a95c2db92fbd7d0155f97127bcb40"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f2fc11e8fe034ee3c34d316d0ad8808f45bc3b9ce5857ff29d513f3ff2923a1"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:586f8204935b9ec884500498ccc91aa869fc652c40c093bd9e1471fbcc25c022"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddc2f4dfd396c7bfa18e6ce371cba60e4cf9d2e5cdb71376aa2da264605b60b9"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ddcba87675b6d509139d1b521e0c8250e967e63b5909a7e8f8944d0f90ff36f"}, + {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7bd339195d84439cbe5771546fe8a4e8a7a045417d8f9de9a368c434e42a721e"}, + {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:d7c36232a90d4755b720fbd76739d8891732b18cf240a9c645d75f00639a9024"}, + {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6b0817e34942b2ca527b0e9298373e7cc75f429e8da2055607f4931fded23e20"}, + {file = "rpds_py-0.18.0-cp39-none-win32.whl", hash = "sha256:99f70b740dc04d09e6b2699b675874367885217a2e9f782bdf5395632ac663b7"}, + {file = "rpds_py-0.18.0-cp39-none-win_amd64.whl", hash = "sha256:6ef687afab047554a2d366e112dd187b62d261d49eb79b77e386f94644363294"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ad36cfb355e24f1bd37cac88c112cd7730873f20fb0bdaf8ba59eedf8216079f"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:36b3ee798c58ace201289024b52788161e1ea133e4ac93fba7d49da5fec0ef9e"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8a2f084546cc59ea99fda8e070be2fd140c3092dc11524a71aa8f0f3d5a55ca"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e4461d0f003a0aa9be2bdd1b798a041f177189c1a0f7619fe8c95ad08d9a45d7"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8db715ebe3bb7d86d77ac1826f7d67ec11a70dbd2376b7cc214199360517b641"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:793968759cd0d96cac1e367afd70c235867831983f876a53389ad869b043c948"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66e6a3af5a75363d2c9a48b07cb27c4ea542938b1a2e93b15a503cdfa8490795"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6ef0befbb5d79cf32d0266f5cff01545602344eda89480e1dd88aca964260b18"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1d4acf42190d449d5e89654d5c1ed3a4f17925eec71f05e2a41414689cda02d1"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a5f446dd5055667aabaee78487f2b5ab72e244f9bc0b2ffebfeec79051679984"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:9dbbeb27f4e70bfd9eec1be5477517365afe05a9b2c441a0b21929ee61048124"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:22806714311a69fd0af9b35b7be97c18a0fc2826e6827dbb3a8c94eac6cf7eeb"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:b34ae4636dfc4e76a438ab826a0d1eed2589ca7d9a1b2d5bb546978ac6485461"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c8370641f1a7f0e0669ddccca22f1da893cef7628396431eb445d46d893e5cd"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c8362467a0fdeccd47935f22c256bec5e6abe543bf0d66e3d3d57a8fb5731863"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11a8c85ef4a07a7638180bf04fe189d12757c696eb41f310d2426895356dcf05"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b316144e85316da2723f9d8dc75bada12fa58489a527091fa1d5a612643d1a0e"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf1ea2e34868f6fbf070e1af291c8180480310173de0b0c43fc38a02929fc0e3"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e546e768d08ad55b20b11dbb78a745151acbd938f8f00d0cfbabe8b0199b9880"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:4901165d170a5fde6f589acb90a6b33629ad1ec976d4529e769c6f3d885e3e80"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:618a3d6cae6ef8ec88bb76dd80b83cfe415ad4f1d942ca2a903bf6b6ff97a2da"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ed4eb745efbff0a8e9587d22a84be94a5eb7d2d99c02dacf7bd0911713ed14dd"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6c81e5f372cd0dc5dc4809553d34f832f60a46034a5f187756d9b90586c2c307"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:43fbac5f22e25bee1d482c97474f930a353542855f05c1161fd804c9dc74a09d"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d7faa6f14017c0b1e69f5e2c357b998731ea75a442ab3841c0dbbbfe902d2c4"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:08231ac30a842bd04daabc4d71fddd7e6d26189406d5a69535638e4dcb88fe76"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:044a3e61a7c2dafacae99d1e722cc2d4c05280790ec5a05031b3876809d89a5c"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3f26b5bd1079acdb0c7a5645e350fe54d16b17bfc5e71f371c449383d3342e17"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:482103aed1dfe2f3b71a58eff35ba105289b8d862551ea576bd15479aba01f66"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1374f4129f9bcca53a1bba0bb86bf78325a0374577cf7e9e4cd046b1e6f20e24"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:635dc434ff724b178cb192c70016cc0ad25a275228f749ee0daf0eddbc8183b1"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:bc362ee4e314870a70f4ae88772d72d877246537d9f8cb8f7eacf10884862432"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4832d7d380477521a8c1644bbab6588dfedea5e30a7d967b5fb75977c45fd77f"}, + {file = "rpds_py-0.18.0.tar.gz", hash = "sha256:42821446ee7a76f5d9f71f9e33a4fb2ffd724bb3e7f93386150b61a43115788d"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +description = "Send file to trash natively under Mac OS X, Windows and Linux" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[package.extras] +nativelib = ["pyobjc-framework-Cocoa", "pywin32"] +objc = ["pyobjc-framework-Cocoa"] +win32 = ["pywin32"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +description = "Sniff out which async library your code is running under" +optional = false +python-versions = ">=3.7" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "soupsieve" +version = "2.5" +description = "A modern CSS selector implementation for Beautiful Soup." +optional = false +python-versions = ">=3.8" +files = [ + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + +[[package]] +name = "terminado" +version = "0.18.1" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +optional = false +python-versions = ">=3.8" +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=6.1.0" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] +typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"] + +[[package]] +name = "tinycss2" +version = "1.2.1" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["flake8", "isort", "pytest"] + +[[package]] +name = "tomli" +version = "2.0.1" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, + {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, +] + +[[package]] +name = "tornado" +version = "6.4" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +optional = false +python-versions = ">= 3.8" +files = [ + {file = "tornado-6.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:02ccefc7d8211e5a7f9e8bc3f9e5b0ad6262ba2fbb683a6443ecc804e5224ce0"}, + {file = "tornado-6.4-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:27787de946a9cffd63ce5814c33f734c627a87072ec7eed71f7fc4417bb16263"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7894c581ecdcf91666a0912f18ce5e757213999e183ebfc2c3fdbf4d5bd764e"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43bc2e5370a6a8e413e1e1cd0c91bedc5bd62a74a532371042a18ef19e10579"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0251554cdd50b4b44362f73ad5ba7126fc5b2c2895cc62b14a1c2d7ea32f212"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fd03192e287fbd0899dd8f81c6fb9cbbc69194d2074b38f384cb6fa72b80e9c2"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:88b84956273fbd73420e6d4b8d5ccbe913c65d31351b4c004ae362eba06e1f78"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:71ddfc23a0e03ef2df1c1397d859868d158c8276a0603b96cf86892bff58149f"}, + {file = "tornado-6.4-cp38-abi3-win32.whl", hash = "sha256:6f8a6c77900f5ae93d8b4ae1196472d0ccc2775cc1dfdc9e7727889145c45052"}, + {file = "tornado-6.4-cp38-abi3-win_amd64.whl", hash = "sha256:10aeaa8006333433da48dec9fe417877f8bcc21f48dda8d661ae79da357b2a63"}, + {file = "tornado-6.4.tar.gz", hash = "sha256:72291fa6e6bc84e626589f1c29d90a5a6d593ef5ae68052ee2ef000dfd273dee"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240316" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-python-dateutil-2.9.0.20240316.tar.gz", hash = "sha256:5d2f2e240b86905e40944dd787db6da9263f0deabef1076ddaed797351ec0202"}, + {file = "types_python_dateutil-2.9.0.20240316-py3-none-any.whl", hash = "sha256:6b8cb66d960771ce5ff974e9dd45e38facb81718cc1e208b10b1baccbfdbee3b"}, +] + +[[package]] +name = "typing-extensions" +version = "4.11.0" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"}, + {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +description = "RFC 6570 URI Template Processor" +optional = false +python-versions = ">=3.7" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[package.extras] +dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"] + +[[package]] +name = "urllib3" +version = "2.2.1" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.1-py3-none-any.whl", hash = "sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d"}, + {file = "urllib3-2.2.1.tar.gz", hash = "sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "1.13" +description = "A library for working with the color formats defined by HTML and CSS." +optional = false +python-versions = ">=3.7" +files = [ + {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"}, + {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"}, +] + +[package.extras] +docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] +tests = ["pytest", "pytest-cov"] + +[[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +optional = false +python-versions = "*" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.7.0" +description = "WebSocket client for Python with low level API options" +optional = false +python-versions = ">=3.8" +files = [ + {file = "websocket-client-1.7.0.tar.gz", hash = "sha256:10e511ea3a8c744631d3bd77e61eb17ed09304c413ad42cf6ddfa4c7787e8fe6"}, + {file = "websocket_client-1.7.0-py3-none-any.whl", hash = "sha256:f4c3d22fec12a2461427a29957ff07d35098ee2d976d3ba244e688b8b4057588"}, +] + +[package.extras] +docs = ["Sphinx (>=6.0)", "sphinx-rtd-theme (>=1.1.0)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + +[[package]] +name = "widgetsnbextension" +version = "4.0.10" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.10-py3-none-any.whl", hash = "sha256:d37c3724ec32d8c48400a435ecfa7d3e259995201fbefa37163124a9fcb393cc"}, + {file = "widgetsnbextension-4.0.10.tar.gz", hash = "sha256:64196c5ff3b9a9183a8e699a4227fb0b7002f252c814098e66c4d1cd0644688f"}, +] + +[metadata] +lock-version = "2.0" +python-versions = "^3.10" +content-hash = "f85acf75253bcc75631a57409c07ffb42fb8ab13bae86f103e5f1ecb4b4557cf" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..f7cd499 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,17 @@ +[tool.poetry] +name = "ephemerality" +version = "1.1.1" +description = "Module for computing ephemerality metrics for temporal activity vectors." +authors = ["Dmitry "] +readme = "README.md" + +[tool.poetry.dependencies] +python = "^3.10" +numpy = "^1.24.2" +pydantic = "^2.7.0" +matplotlib = "^3.8.4" +jupyter = "^1.0.0" + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/requirements-rest.txt b/requirements-rest.txt new file mode 100644 index 0000000..a488c44 --- /dev/null +++ b/requirements-rest.txt @@ -0,0 +1,2 @@ +fastapi~=0.110.0 +uvicorn~=0.21.1 diff --git a/requirements-test.txt b/requirements-test.txt deleted file mode 100644 index 62a159b..0000000 --- a/requirements-test.txt +++ /dev/null @@ -1,3 +0,0 @@ -requests~=2.28.2 -memory-profiler~=0.61.0 -pytest~=7.3.1 diff --git a/requirements.txt b/requirements.txt index 525eaf8..c569fb9 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,3 @@ -numpy~=1.24.2 -fastapi~=0.95.1 -setuptools~=67.6.1 -pydantic~=1.10.7 -uvicorn~=0.21.1 +numpy~=1.24.2 +setuptools~=67.6.1 +pydantic~=1.10.7 diff --git a/setup.py b/setup.py index cd48e69..090b548 100644 --- a/setup.py +++ b/setup.py @@ -1,46 +1,40 @@ -import os -from setuptools import setup -import re - -VERSION_FILE = "ephemerality/_version.py" -VERSION_REGEX = r"^__version__ = ['\"]([^'\"]*)['\"]" - - -def read(file_name): - return open(os.path.join(os.path.dirname(__file__), file_name), 'rt').read() - - -version_lines = open(VERSION_FILE, 'r').read() -match = re.search(VERSION_REGEX, version_lines, re.M) -if match: - version = match.group(1) -else: - raise RuntimeError("Unable to find version string in %s." % (VERSION_FILE,)) - -setup( - name='ephemerality', - version=version, - packages=['ephemerality'], - url='https://github.com/HPAI-BSC/ephemerality', - license='MIT', - license_files=['./LICENSE'], - author='HPAI BSC', - author_email='dmitry.gnatyshak@bsc.es', - description='Module for computing ephemerality metrics of temporal activity arrays.', - long_description=read('README.md'), - scripts=[], - install_requires=[ - 'numpy~=1.24.2', - 'fastapi~=0.95.1', - 'setuptools~=67.6.1', - 'pydantic~=1.10.7', - 'uvicorn~=0.21.1' - ], - extras_require={ - 'test': [ - 'requests~=2.28.2', - 'memory-profiler~=0.61.0', - 'pytest~=7.3.1' - ] - } -) +import os +from setuptools import setup +import re + +VERSION_FILE = "ephemerality/_version.py" +VERSION_REGEX = r"^__version__ = ['\"]([^'\"]*)['\"]" + + +def read(file_name): + return open(os.path.join(os.path.dirname(__file__), file_name), 'rt', encoding="utf8").read() + + +version_lines = open(VERSION_FILE, 'r').read() +match = re.search(VERSION_REGEX, version_lines, re.M) +if match: + version = match.group(1) +else: + raise RuntimeError("Unable to find version string in %s." % (VERSION_FILE,)) + +with open('requirements.txt', 'r') as f: + requirements = list(f.read().splitlines()) + +with open('requirements-rest.txt', 'r') as f: + requirements_rest = list(f.read().splitlines()) + +setup( + name='ephemerality', + version=version, + packages=['ephemerality'], + url='https://github.com/HPAI-BSC/ephemerality', + license='MIT', + license_files=['./LICENSE'], + author='HPAI BSC', + author_email='dmitry.gnatyshak@bsc.es', + description='Module for computing ephemerality metrics for temporal activity vectors.', + long_description=read('README.md'), + scripts=[], + install_requires=requirements, + extras_require={'rest':requirements_rest} +) diff --git a/testing/__init__.py b/testing/__init__.py index af2aba1..2afb534 100644 --- a/testing/__init__.py +++ b/testing/__init__.py @@ -1,4 +1,4 @@ -from testing.src import generate_data, generate_test_case, clear_data - - -__all__ = [generate_data, generate_test_case, clear_data] +from testing.src import generate_data, generate_test_case, clear_data + + +__all__ = ['generate_data', 'generate_test_case', 'clear_data'] diff --git a/testing/run_data_generator.py b/testing/run_data_generator.py index ca95c5f..bae22fb 100644 --- a/testing/run_data_generator.py +++ b/testing/run_data_generator.py @@ -1,59 +1,61 @@ -#!/usr/bin/env python3 - -from argparse import ArgumentParser - -from testing import generate_data - - -def init_parser() -> ArgumentParser: - parser = ArgumentParser( - usage="python3 %(prog)s [-o OUTPUT_FOLDER][-g] [-d DATA_TYPE] [--data_range START END] " - "[-n MAX_TEST_SIZE] [-m CASES_PER_BATCH] [-s SEED] ...", - description="Generate data for tests." - ) - parser.add_argument( - "-o", "--output_folder", action="store", default="./test_data/", - help="Path to the folder to store generated test cases. Defaults to \"./test_data/\"." - ) - parser.add_argument( - "-d", "--data_type", action="store", choices=["activity", "a", "timestamps", "t", "datetime", "d"], default="a", - help="Type of the generated data. Defaults to \"a\"." - ) - parser.add_argument( - "--data_range", action="store", type=float, nargs=2, default=None, - help="Value range for timestamps or datetime data types in UNIX timestamp in seconds. " - "Passed as 2 integer numbers. Defaults to (0, 31536000)." - ) - parser.add_argument( - "-n", "--max_size", action="store", type=int, default=6, - help="Maximal size (in power 10) of test size batches. Defaults to 6." - ) - parser.add_argument( - "-m", "--cases_per_batch", action="store", type=int, default=20, - help="Number of test cases in each size batch. Defaults to 20." - ) - parser.add_argument( - "-s", "--seed", action="store", type=int, default=2023, - help="Value of the seed to be used for test case generation. Defaults to 2023." - ) - return parser - - -if __name__ == '__main__': - parser = init_parser() - args = parser.parse_args() - if args.data_range is None: - args.data_range = (0, 31536000) - - if args.max_size <= 0: - raise ValueError("\"max_size\" value should be positive!") - if args.cases_per_batch <= 0: - raise ValueError("\"cases_per_batch\" value should be positive!") - - generate_data( - max_size=args.max_size, - inputs_per_n=args.cases_per_batch, - data_type=args.data_type, - data_range=args.data_range, - seed=args.seed, - save_dir=args.output_folder) +#!/usr/bin/env python3 + +from argparse import ArgumentParser +import sys +from pathlib import Path + +from testing.src import generate_data + + +def init_parser() -> ArgumentParser: + parser = ArgumentParser( + usage=f"{Path(sys.executable).stem} %(prog)s [-o OUTPUT_FOLDER][-g] [-d DATA_TYPE] [--data_range START END] " + "[-n MAX_TEST_SIZE] [-m CASES_PER_BATCH] [-s SEED] ...", + description="Generate data for tests." + ) + parser.add_argument( + "-o", "--output_folder", action="store", default="./test_data/", + help="Path to the folder to store generated test cases. Defaults to \"./test_data/\"." + ) + parser.add_argument( + "-d", "--data_type", action="store", choices=["activity", "a", "timestamps", "t", "datetime", "d"], default="a", + help="Type of the generated data. Defaults to \"a\"." + ) + parser.add_argument( + "--data_range", action="store", type=float, nargs=2, default=None, + help="Value range for timestamps or datetime data types in UNIX timestamp in seconds. " + "Passed as 2 integer numbers. Defaults to (0, 31536000)." + ) + parser.add_argument( + "-n", "--max_size", action="store", type=int, default=6, + help="Maximal size (in power 10) of test size batches. Defaults to 6." + ) + parser.add_argument( + "-m", "--cases_per_batch", action="store", type=int, default=20, + help="Number of test cases in each size batch. Defaults to 20." + ) + parser.add_argument( + "-s", "--seed", action="store", type=int, default=2023, + help="Value of the seed to be used for test case generation. Defaults to 2023." + ) + return parser + + +if __name__ == '__main__': + parser = init_parser() + args = parser.parse_args() + if args.data_range is None: + args.data_range = (0, 31536000) + + if args.max_size <= 0: + raise ValueError("\"max_size\" value should be positive!") + if args.cases_per_batch <= 0: + raise ValueError("\"cases_per_batch\" value should be positive!") + + generate_data( + max_size=args.max_size, + inputs_per_n=args.cases_per_batch, + data_type=args.data_type, + data_range=args.data_range, + seed=args.seed, + save_dir=args.output_folder) diff --git a/testing/run_performance_tests.py b/testing/run_performance_tests.py deleted file mode 100644 index 555c6e7..0000000 --- a/testing/run_performance_tests.py +++ /dev/null @@ -1,142 +0,0 @@ -#!/usr/bin/env python3 - -import json -from argparse import ArgumentParser -import os -from pathlib import Path -from pprint import pprint - -from testing import generate_data, clear_data -from testing.src import test_performance - - -def init_parser() -> ArgumentParser: - parser = ArgumentParser( - usage="python3 %(prog)s [TYPE(s)] [-h] [-u URL] [-i INPUT_FOLDER] [-o OUTPUT_FILE] [--merge_output] " - "[-r TESTS_PER_CASE] [-g] [-d DATA_TYPE] [--data_range START END] [-n MAX_TEST_SIZE] " - "[-m CASES_PER_BATCH] [-s SEED] [-k] ...", - description="Run performance tests." - ) - parser.add_argument( - "-u", "--url", action="store", default="", - help="URL of REST web service. If not provided, will run tests on command line script instead." - ) - parser.add_argument( - "-i", "--input_folder", action="store", default="./test_data/", - help="Path to the folder with test cases. It will be created if it doesn't exist. " - "Defaults to \"./test_data/\"." - ) - parser.add_argument( - "-o", "--output_file", action="store", default="./test_results.json", - help="Name and path to the JSON file to which the test results will be written. The path will be created if needed. " - "Defaults to \"./test_results.json\"." - ) - parser.add_argument( - "--merge_output", action="store_true", - help="Merges the output of the test with the existing content of the file in top-level array. By default the " - "file is overwritten." - ) - parser.add_argument( - "-r", "--tests_per_case", action="store", type=int, default=20, - help="Number of test repetitions per test case per test. Defaults to 20." - ) - parser.add_argument( - "-g", "--generate", action="store_true", - help="Generate test cases using numpy random number generator. Will generate N batches of inputs. Each one " - "will contain M JSON files with thresholds and input vectors, " - "each vector is of length 10^[batch number from 1 to N]. " - "WARNING: will rewrite the contents of the input folder." - ) - parser.add_argument( - "-d", "--data_type", action="store", choices=["activity", "a", "timestamps", "t", "datetime", "d"], default="a", - help="Type of the generated data. Defaults to \"a\"." - ) - parser.add_argument( - "--data_range", action="store", type=float, nargs=2, default=None, - help="Value range for timestamps or datetime data types in UNIX timestamp in seconds. " - "Passed as 2 integer numbers. Defaults to (0, 31536000)." - ) - parser.add_argument( - "-n", "--max_size", action="store", type=int, default=6, - help="Maximal size (in power 10) of test size batches. Defaults to 6." - ) - parser.add_argument( - "-m", "--cases_per_batch", action="store", type=int, default=20, - help="Number of test cases in each size batch. Defaults to 20." - ) - parser.add_argument( - "-s", "--seed", action="store", type=int, default=2023, - help="Value of the seed to be used for test case generation. Defaults to 2023." - ) - parser.add_argument( - "-k", "--keep_data", action="store_true", - help="Keep generated test data after tests finish. All GENERATED data will be removed otherwise." - ) - parser.add_argument( - 'types', action="store", default="tr", nargs='?', - help='test types: \"t\" for computation time, \"r\" for RAM usage. Defaults to \"tr\"' - ) - return parser - - -if __name__ == '__main__': - parser = init_parser() - args = parser.parse_args() - if args.data_range is None: - args.data_range = (0, 31536000) - - if args.tests_per_case <= 0: - raise ValueError("\"tests_per_case\" value should be positive!") - if args.max_size <= 0: - raise ValueError("\"max_size\" value should be positive!") - if args.cases_per_batch <= 0: - raise ValueError("\"cases_per_batch\" value should be positive!") - - # Data - if args.generate: - generate_data( - max_size=args.max_size, - inputs_per_n=args.cases_per_batch, - data_type=args.data_type, - data_range=args.data_range, - seed=args.seed, - save_dir=args.input_folder) - else: - if not os.path.exists(args.input_folder): - raise FileNotFoundError("Input folder does not exist and no data generation has been requested!") - elif not os.path.isdir(args.input_folder): - raise NotADirectoryError("Specified input folder is not a directory.") - - # Test - results = test_performance( - input_folder=args.input_folder, - url=args.url, - types=args.types, - tests_per_case=args.tests_per_case - ) - pprint(results) - - # Save results - if args.output_file: - output_file = Path(args.output_file).resolve() - if not output_file.exists(): - if not output_file.parent.exists(): - output_file.parent.mkdir(parents=True) - mode = "w" - else: - mode = "w+" if args.merge_output else "w" - - with open(output_file, mode) as f: - if mode == "w": - json.dump(results, f, indent=2, sort_keys=True) - else: - previous_output = json.load(f) - if isinstance(previous_output, list): - previous_output.append(results) - json.dump(previous_output, f) - else: - json.dump([previous_output, results], f) - - # Clear data - if args.generate and not args.keep_data: - clear_data(args.input_folder) diff --git a/testing/run_unit_tests.py b/testing/run_unit_tests.py index 97ea3eb..c5856ac 100644 --- a/testing/run_unit_tests.py +++ b/testing/run_unit_tests.py @@ -1,7 +1,7 @@ -#!/usr/bin/env python3 - -from testing.src import test_ephemerality - - -if __name__ == "__main__": - test_ephemerality() +#!/usr/bin/env python3 + +from testing.src import test_ephemerality + + +if __name__ == "__main__": + test_ephemerality() diff --git a/testing/src/__init__.py b/testing/src/__init__.py index 98aec0f..f5367ba 100644 --- a/testing/src/__init__.py +++ b/testing/src/__init__.py @@ -1,6 +1,5 @@ -from testing.src.data_generator import generate_test_case, generate_data, clear_data -from testing.src.test_ephemerality import test_ephemerality -from testing.src.test_performance import test_performance - - -__all__ = [generate_test_case, generate_data, clear_data, test_ephemerality, test_performance] +from testing.src.data_generator import generate_test_case, generate_data, clear_data +from testing.src.test_ephemerality import test_ephemerality + + +__all__ = ['generate_test_case', 'generate_data', 'clear_data', 'test_ephemerality'] diff --git a/testing/src/data_generator.py b/testing/src/data_generator.py index 3c2cd49..85ab98e 100644 --- a/testing/src/data_generator.py +++ b/testing/src/data_generator.py @@ -1,94 +1,93 @@ -import json -import os -import numpy as np -from pathlib import Path -import shutil -from datetime import datetime - - -def generate_test_case( - size: int, - data_type: str, - data_range: tuple[float, float] | None = None, - seed: None | int = None, - activity_length: None | int = None -) -> tuple[float, list[float | str]]: - - if activity_length is None: - activity_length = size - activity = np.zeros((activity_length,)) - rng = np.random.default_rng(seed) - threshold = float(rng.uniform(low=0.1, high=0.9, size=None)) - activity[0] = rng.normal(scale=10) - for i in range(1, activity_length): - activity[i] = activity[i - 1] + rng.normal() - activity -= np.mean(activity) - activity = activity.clip(min=0) - - if data_type == "activity" or data_type == "a": - activity /= np.sum(activity) - return threshold, list(activity) - - activity_granule_length = int(np.ceil((data_range[1] - data_range[0]) / activity_length)) - activity = activity.repeat(activity_granule_length)[:(data_range[1] - data_range[0])] - activity /= np.sum(activity) - - timestamps = rng.choice( - a=np.arange(data_range[0], data_range[1]).astype(int), - size=size, - p=activity - ) - timestamps.sort() - - if data_type == "timestamps" or data_type == "t": - return threshold, list(timestamps.astype(str)) - - return threshold, [datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ").replace("000000Z", "000Z") - for ts in timestamps] - - -def generate_data( - max_size: int = 10, - inputs_per_n: int = 100, - data_type: str = "a", - data_range: tuple[float, float] | None = None, - seed: int = 2023, - save_dir: str = "./test_data/" -) -> None: - if save_dir and save_dir[-1] != '/': - save_dir += '/' - - for n in range(1, max_size + 1): - dir_n = Path(f"{save_dir}{n}") - dir_n.mkdir(parents=True, exist_ok=True) - - for i in range(inputs_per_n): - size = 10 ** n - test_case = generate_test_case( - size=size, - data_type=data_type, - data_range=data_range, - seed=seed + i, - activity_length=None if data_type == "activity" or data_type == "a" else int((data_range[1] - data_range[0]) / 1000) - ) - test_data = [{ - "threshold": test_case[0], - "input_sequence": test_case[1], - "input_type": data_type, - "range": [str(data_range[0]), str(data_range[1])], - "reference_name": f"{data_type}_{size}_{i}" - }] - - with open(f"{dir_n}/{i}.json", "w") as f: - json.dump(test_data, f) - - -def clear_data(folder: str) -> None: - for file in Path(folder).iterdir(): - try: - if file.is_file() or file.is_symlink(): - file.unlink() - elif file.is_dir(): - shutil.rmtree(file) - except Exception as ex: - print(f'Failed to delete {file.resolve()}. Reason: {ex}') +import json +import numpy as np +from pathlib import Path +import shutil +from datetime import datetime + + +def generate_test_case( + size: int, + data_type: str, + data_range: tuple[float, float] | None = None, + seed: None | int = None, + activity_length: None | int = None +) -> tuple[float, list[float | str]]: + + if activity_length is None: + activity_length = size + activity = np.zeros((activity_length,)) + rng = np.random.default_rng(seed) + threshold = float(rng.uniform(low=0.1, high=0.9, size=None)) + activity[0] = rng.normal(scale=10) + for i in range(1, activity_length): + activity[i] = activity[i - 1] + rng.normal() + activity -= np.mean(activity) + activity = activity.clip(min=0) + + if data_type == "activity" or data_type == "a": + activity /= np.sum(activity) + return threshold, list(activity) + + activity_granule_length = int(np.ceil((data_range[1] - data_range[0]) / activity_length)) + activity = activity.repeat(activity_granule_length)[:(data_range[1] - data_range[0])] + activity /= np.sum(activity) + + timestamps = rng.choice( + a=np.arange(data_range[0], data_range[1]).astype(int), + size=size, + p=activity + ) + timestamps.sort() + + if data_type == "timestamps" or data_type == "t": + return threshold, list(timestamps.astype(str)) + + return threshold, [datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ").replace("000000Z", "000Z") + for ts in timestamps] + + +def generate_data( + max_size: int = 10, + inputs_per_n: int = 100, + data_type: str = "a", + data_range: tuple[float, float] | None = None, + seed: int = 2023, + save_dir: str = "./test_data/" +) -> None: + if save_dir and save_dir[-1] != '/': + save_dir += '/' + + for n in range(1, max_size + 1): + dir_n = Path(f"{save_dir}{n}") + dir_n.mkdir(parents=True, exist_ok=True) + + for i in range(inputs_per_n): + size = 10 ** n + test_case = generate_test_case( + size=size, + data_type=data_type, + data_range=data_range, + seed=seed + i, + activity_length=None if data_type == "activity" or data_type == "a" else int((data_range[1] - data_range[0]) / 1000) + ) + test_data = [{ + "threshold": test_case[0], + "input_sequence": test_case[1], + "input_type": data_type, + "range": [str(data_range[0]), str(data_range[1])], + "reference_name": f"{data_type}_{size}_{i}" + }] + + with open(f"{dir_n}/{i}.json", "w") as f: + json.dump(test_data, f) + + +def clear_data(folder: str) -> None: + for file in Path(folder).iterdir(): + try: + if file.is_file() or file.is_symlink(): + file.unlink() + elif file.is_dir(): + shutil.rmtree(file) + except Exception as ex: + print(f'Failed to delete {file.resolve()}. Reason: {ex}') diff --git a/testing/src/test_ephemerality.py b/testing/src/test_ephemerality.py index a5b8f21..d9f5261 100644 --- a/testing/src/test_ephemerality.py +++ b/testing/src/test_ephemerality.py @@ -1,683 +1,683 @@ -from unittest import TestCase, TextTestRunner -import numpy as np -from typing import Sequence -from testing.src.test_utils import EphemeralityTestCase -from ephemerality import compute_ephemerality, EphemeralitySet - - -DEFAULT_TEST_CASES = [ - EphemeralityTestCase( - input_sequence=[1.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0.375, - eph_middle_core=0.375, - eph_right_core=0., - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.375, - eph_right_core=0.375, - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[.5, .5], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=2, - len_right_core=2, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[.5, .5], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0.7, .3], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=2, - len_right_core=2, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0.7, .3], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=4, - len_sorted_core=1, - eph_left_core=0.6875, - eph_middle_core=0.6875, - eph_right_core=0., - eph_sorted_core=0.6875 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=4, - len_sorted_core=1, - eph_left_core=1 / 6, - eph_middle_core=1 / 6, - eph_right_core=0., - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=4, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.6875, - eph_right_core=0.6875, - eph_sorted_core=0.6875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=4, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=1 / 6, - eph_right_core=1 / 6, - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1., 0., 1.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=4, - len_middle_core=3, - len_right_core=3, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0.0625, - eph_right_core=0.0625, - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 1., 0., 1.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=1 / 6, - eph_right_core=1 / 6, - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 1., 1.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=4, - len_middle_core=4, - len_right_core=4, - len_sorted_core=4, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 1., 1.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=2, - len_right_core=2, - len_sorted_core=2, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=2, - len_right_core=4, - len_sorted_core=2, - eph_left_core=0.375, - eph_middle_core=0.375, - eph_right_core=0., - eph_sorted_core=0.375 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 1., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=3, - len_sorted_core=1, - eph_left_core=1 / 6, - eph_middle_core=1 / 6, - eph_right_core=0, - eph_sorted_core=1 / 6 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=10, - len_sorted_core=1, - eph_left_core=0.875, - eph_middle_core=0.875, - eph_right_core=0., - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=10, - len_sorted_core=1, - eph_left_core=2 / 3, - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=5, - len_middle_core=1, - len_right_core=6, - len_sorted_core=1, - eph_left_core=0.375, - eph_middle_core=0.875, - eph_right_core=0.25, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=5, - len_middle_core=1, - len_right_core=6, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=3, - len_middle_core=1, - len_right_core=8, - len_sorted_core=1, - eph_left_core=0.625, - eph_middle_core=0.875, - eph_right_core=0., - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=3, - len_middle_core=1, - len_right_core=8, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=4, - len_middle_core=1, - len_right_core=7, - len_sorted_core=1, - eph_left_core=0.5, - eph_middle_core=0.875, - eph_right_core=0.125, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=4, - len_middle_core=1, - len_right_core=7, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=8, - len_middle_core=1, - len_right_core=3, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.875, - eph_right_core=0.625, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=8, - len_middle_core=1, - len_right_core=3, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=9, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.875, - eph_right_core=0.75, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=9, - len_middle_core=1, - len_right_core=2, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=1 / 3, - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=10, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=0.875, - eph_right_core=0.875, - eph_sorted_core=0.875 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=10, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=2 / 3, - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=8, - len_middle_core=8, - len_right_core=8, - len_sorted_core=8, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=3, - len_middle_core=3, - len_right_core=3, - len_sorted_core=3, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=7, - len_middle_core=4, - len_right_core=6, - len_sorted_core=3, - eph_left_core=0.125, - eph_middle_core=0.5, - eph_right_core=0.25, - eph_sorted_core=0.625 - ) - ), - EphemeralityTestCase( - input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=5, - len_middle_core=1, - len_right_core=6, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2 / 3, - eph_right_core=0., - eph_sorted_core=2 / 3 - ) - ), - EphemeralityTestCase( - input_sequence=np.eye(1, 10000, k=5000).flatten(), - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=5001, - len_middle_core=1, - len_right_core=5000, - len_sorted_core=1, - eph_left_core=0.374875, - eph_middle_core=0.999875, - eph_right_core=0.375, - eph_sorted_core=0.999875 - ) - ), - EphemeralityTestCase( - input_sequence=np.eye(1, 10000, k=5000).flatten(), - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=5001, - len_middle_core=1, - len_right_core=5000, - len_sorted_core=1, - eph_left_core=0., - eph_middle_core=2999 / 3000, - eph_right_core=0., - eph_sorted_core=2999 / 3000 - ) - ), - EphemeralityTestCase( - input_sequence=np.ones((10000,)), - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=8000, - len_middle_core=8000, - len_right_core=8000, - len_sorted_core=8000, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=np.ones((10000,)), - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=3000, - len_middle_core=3000, - len_right_core=3000, - len_sorted_core=3000, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0. - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=10000, - len_middle_core=10000, - len_right_core=10000, - len_sorted_core=4, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=0.9995 - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=2, - len_middle_core=9998, - len_right_core=2, - len_sorted_core=2, - eph_left_core=1499 / 1500, - eph_middle_core=0., - eph_right_core=1499 / 1500, - eph_sorted_core=1499 / 1500 - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), - threshold=0.8, - expected_output=EphemeralitySet( - len_left_core=10001, - len_middle_core=10001, - len_right_core=10001, - len_sorted_core=3, - eph_left_core=0., - eph_middle_core=0., - eph_right_core=0., - eph_sorted_core=39989 / 40004 - ) - ), - EphemeralityTestCase( - input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), - threshold=0.3, - expected_output=EphemeralitySet( - len_left_core=1, - len_middle_core=1, - len_right_core=1, - len_sorted_core=1, - eph_left_core=29993 / 30003, - eph_middle_core=29993 / 30003, - eph_right_core=29993 / 30003, - eph_sorted_core=29993 / 30003 - ) - ) -] - - -class TestComputeEphemerality(TestCase): - test_cases: Sequence[EphemeralityTestCase] = DEFAULT_TEST_CASES - - def test_compute_ephemeralities(self): - for i, test_case in enumerate(self.test_cases): - with self.subTest(): - print(f'Running test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') - - actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, - threshold=test_case.threshold) - - try: - self.assertEquals(test_case.expected_output, actual_output) - except AssertionError as ex: - print(f"\tAssertion error while processing test case {i}: {test_case.input_sequence}, " - f"threshold {test_case.threshold}...") - print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") - raise ex - - -def test_ephemerality(test_cases: list[EphemeralityTestCase] | None = None) -> None: - if test_cases is None: - test_cases = DEFAULT_TEST_CASES - test = TestComputeEphemerality('test_compute_ephemeralities') - test.test_cases = test_cases - - runner = TextTestRunner() - runner.run(test) +from unittest import TestCase, TextTestRunner +import numpy as np +from typing import Sequence +from testing.src.test_utils import EphemeralityTestCase +from ephemerality import compute_ephemerality, EphemeralitySet + + +DEFAULT_TEST_CASES = [ + EphemeralityTestCase( + input_sequence=[1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0.375, + eph_middle_core=0.375, + eph_right_core=0., + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.375, + eph_right_core=0.375, + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.5, .5], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.5, .5], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0.7, .3], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0.7, .3], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=4, + len_sorted_core=1, + eph_left_core=0.6875, + eph_middle_core=0.6875, + eph_right_core=0., + eph_sorted_core=0.6875 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=4, + len_sorted_core=1, + eph_left_core=1 / 6, + eph_middle_core=1 / 6, + eph_right_core=0., + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.6875, + eph_right_core=0.6875, + eph_sorted_core=0.6875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=1 / 6, + eph_right_core=1 / 6, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1., 0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=3, + len_right_core=3, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0.0625, + eph_right_core=0.0625, + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 1., 0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=1 / 6, + eph_right_core=1 / 6, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 1., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=4, + len_right_core=4, + len_sorted_core=4, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 1., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=2, + len_sorted_core=2, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=2, + len_right_core=4, + len_sorted_core=2, + eph_left_core=0.375, + eph_middle_core=0.375, + eph_right_core=0., + eph_sorted_core=0.375 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 1., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=1 / 6, + eph_middle_core=1 / 6, + eph_right_core=0, + eph_sorted_core=1 / 6 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=10, + len_sorted_core=1, + eph_left_core=0.875, + eph_middle_core=0.875, + eph_right_core=0., + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=10, + len_sorted_core=1, + eph_left_core=2 / 3, + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0.375, + eph_middle_core=0.875, + eph_right_core=0.25, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=3, + len_middle_core=1, + len_right_core=8, + len_sorted_core=1, + eph_left_core=0.625, + eph_middle_core=0.875, + eph_right_core=0., + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=3, + len_middle_core=1, + len_right_core=8, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=7, + len_sorted_core=1, + eph_left_core=0.5, + eph_middle_core=0.875, + eph_right_core=0.125, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=4, + len_middle_core=1, + len_right_core=7, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=8, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.625, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=8, + len_middle_core=1, + len_right_core=3, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=9, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.75, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=9, + len_middle_core=1, + len_right_core=2, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=1 / 3, + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=10, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=0.875, + eph_right_core=0.875, + eph_sorted_core=0.875 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=10, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=2 / 3, + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=8, + len_middle_core=8, + len_right_core=8, + len_sorted_core=8, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[.1, .1, .1, .1, .1, .1, .1, .1, .1, .1], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=3, + len_middle_core=3, + len_right_core=3, + len_sorted_core=3, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=7, + len_middle_core=4, + len_right_core=6, + len_sorted_core=3, + eph_left_core=0.125, + eph_middle_core=0.5, + eph_right_core=0.25, + eph_sorted_core=0.625 + ) + ), + EphemeralityTestCase( + input_sequence=[0., 0., 0., .2, .55, 0., .15, .1, 0., 0.], + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=5, + len_middle_core=1, + len_right_core=6, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2 / 3, + eph_right_core=0., + eph_sorted_core=2 / 3 + ) + ), + EphemeralityTestCase( + input_sequence=np.eye(1, 10000, k=5000).flatten(), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=5001, + len_middle_core=1, + len_right_core=5000, + len_sorted_core=1, + eph_left_core=0.374875, + eph_middle_core=0.999875, + eph_right_core=0.375, + eph_sorted_core=0.999875 + ) + ), + EphemeralityTestCase( + input_sequence=np.eye(1, 10000, k=5000).flatten(), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=5001, + len_middle_core=1, + len_right_core=5000, + len_sorted_core=1, + eph_left_core=0., + eph_middle_core=2999 / 3000, + eph_right_core=0., + eph_sorted_core=2999 / 3000 + ) + ), + EphemeralityTestCase( + input_sequence=np.ones((10000,)), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=8000, + len_middle_core=8000, + len_right_core=8000, + len_sorted_core=8000, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=np.ones((10000,)), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=3000, + len_middle_core=3000, + len_right_core=3000, + len_sorted_core=3000, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0. + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=10000, + len_middle_core=10000, + len_right_core=10000, + len_sorted_core=4, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=0.9995 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.zeros((9996,)), pad_width=(2, 2), constant_values=(1., 1.)), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=2, + len_middle_core=9998, + len_right_core=2, + len_sorted_core=2, + eph_left_core=1499 / 1500, + eph_middle_core=0., + eph_right_core=1499 / 1500, + eph_sorted_core=1499 / 1500 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), + threshold=0.8, + expected_output=EphemeralitySet( + len_left_core=10001, + len_middle_core=10001, + len_right_core=10001, + len_sorted_core=3, + eph_left_core=0., + eph_middle_core=0., + eph_right_core=0., + eph_sorted_core=39989 / 40004 + ) + ), + EphemeralityTestCase( + input_sequence=np.pad(np.eye(1, 9999, k=4999).flatten(), pad_width=(1, 1), constant_values=(1., 1.)), + threshold=0.3, + expected_output=EphemeralitySet( + len_left_core=1, + len_middle_core=1, + len_right_core=1, + len_sorted_core=1, + eph_left_core=29993 / 30003, + eph_middle_core=29993 / 30003, + eph_right_core=29993 / 30003, + eph_sorted_core=29993 / 30003 + ) + ) +] + + +class TestComputeEphemerality(TestCase): + test_cases: Sequence[EphemeralityTestCase] = DEFAULT_TEST_CASES + + def test_compute_ephemeralities(self): + for i, test_case in enumerate(self.test_cases): + with self.subTest(): + print(f'Running test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') + + actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, + threshold=test_case.threshold) + + try: + self.assertEquals(test_case.expected_output, actual_output) + except AssertionError as ex: + print(f"\tAssertion error while processing test case {i}: {test_case.input_sequence}, " + f"threshold {test_case.threshold}...") + print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") + raise ex + + +def test_ephemerality(test_cases: list[EphemeralityTestCase] | None = None) -> None: + if test_cases is None: + test_cases = DEFAULT_TEST_CASES + test = TestComputeEphemerality('test_compute_ephemeralities') + test.test_cases = test_cases + + runner = TextTestRunner() + runner.run(test) diff --git a/testing/src/test_performance.py b/testing/src/test_performance.py deleted file mode 100644 index b846c23..0000000 --- a/testing/src/test_performance.py +++ /dev/null @@ -1,73 +0,0 @@ -import json -import sys -from pathlib import Path -from subprocess import check_output - -import requests - - -def test_performance( - input_folder: str, - url: str | None, - types: str, - tests_per_case: int -) -> dict[str, dict[str, list]]: - results = {} - if url: - if url[-1] != '/': - url += '/' - if 't' in types: - time_results = {} - for json_file in Path(input_folder).rglob("*.json"): - with open(json_file, 'r') as f: - test_case = json.load(f) - case_times = [] - for i in range(tests_per_case): - response = requests.post(f"{url}?test_time_reps={1}", json=test_case) - case_times.append(response.json()["time"][0]) - time_results[str(json_file.resolve())] = case_times - results["time"] = time_results - if 'r' in types: - ram_results = {} - for json_file in Path(input_folder).rglob("*.json"): - with open(json_file, 'r') as f: - test_case = json.load(f) - case_rams = [] - for i in range(tests_per_case): - response = requests.post(f"{url}?test_ram_reps={1}", json=test_case) - case_rams.append(response.json()["RAM"][0]) - ram_results[str(json_file.resolve())] = case_rams - results["RAM"] = ram_results - else: - if 't' in types: - time_results = {} - for json_file in Path(input_folder).rglob("*.json"): - print(json_file.resolve()) - case_times = [] - for i in range(tests_per_case): - run_results = check_output([ - "python3", "-m", "ephemerality", "cmd", - "-i", str(json_file.resolve()), - "--test_time_reps", "1" - ]).decode(sys.stdout.encoding) - run_results = json.loads(run_results)["time"] - case_times.append(run_results[list(run_results.keys())[0]][0]) - time_results[str(json_file.resolve())] = case_times - results["time"] = time_results - if 'r' in types: - ram_results = {} - for json_file in Path(input_folder).rglob("*.json"): - print(json_file.resolve()) - case_rams = [] - for i in range(tests_per_case): - run_results = check_output([ - "python", "ephemerality_cmd.py", - "-i", str(json_file.resolve()), - "--test_ram_reps", "1" - ]).decode(sys.stdout.encoding) - run_results = json.loads(run_results)["RAM"] - case_rams.append(run_results[list(run_results.keys())[0]][0]) - ram_results[str(json_file.resolve())] = case_rams - results["RAM"] = ram_results - - return results diff --git a/testing/src/test_utils.py b/testing/src/test_utils.py index 7433976..4d5b00f 100644 --- a/testing/src/test_utils.py +++ b/testing/src/test_utils.py @@ -1,11 +1,11 @@ -from typing import Sequence -from dataclasses import dataclass - -from ephemerality import EphemeralitySet - - -@dataclass -class EphemeralityTestCase: - input_sequence: Sequence[float] - threshold: float - expected_output: EphemeralitySet +from typing import Sequence +from dataclasses import dataclass + +from ephemerality import EphemeralitySet + + +@dataclass +class EphemeralityTestCase: + input_sequence: Sequence[float] + threshold: float + expected_output: EphemeralitySet From 3eebdb3a3116050bb47c11cc734a5b63eed7d7e9 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 30 Apr 2024 17:53:05 +0200 Subject: [PATCH 11/11] Release v2.0.0. Updated input and output formats, new CMD and API modes, expanded readme. --- Dockerfile | 15 +- README.md | 402 +-- dist/ephemerality-2.0.0-py3-none-any.whl | Bin 0 -> 20555 bytes dist/ephemerality-2.0.0.tar.gz | Bin 0 -> 16521 bytes ephemerality/__init__.py | 4 +- ephemerality/__main__.py | 6 +- ephemerality/rest/api.py | 4 +- ephemerality/rest/api_versions/__init__.py | 4 +- .../rest/api_versions/api_template.py | 4 +- ephemerality/scripts/ephemerality_api.py | 23 +- ephemerality/scripts/ephemerality_cmd.py | 60 +- ephemerality/src/data_processing.py | 53 +- ephemerality/src/ephemerality_computation.py | 14 +- ephemerality/src/utils.py | 17 +- images/example_1.png | Bin 0 -> 16014 bytes images/example_2.png | Bin 0 -> 15469 bytes images/example_3.png | Bin 0 -> 12572 bytes images/example_4.png | Bin 0 -> 13693 bytes images/results_1.png | Bin 0 -> 46478 bytes images/results_2.png | Bin 0 -> 41776 bytes images/results_3.png | Bin 0 -> 43562 bytes images/results_4.png | Bin 0 -> 51908 bytes poetry.lock | 2215 +---------------- pyproject.toml | 9 +- requirements-rest.txt | 2 - requirements.txt | 3 - setup.py | 40 - testing/src/test_ephemerality.py | 109 +- 28 files changed, 547 insertions(+), 2437 deletions(-) create mode 100644 dist/ephemerality-2.0.0-py3-none-any.whl create mode 100644 dist/ephemerality-2.0.0.tar.gz create mode 100644 images/example_1.png create mode 100644 images/example_2.png create mode 100644 images/example_3.png create mode 100644 images/example_4.png create mode 100644 images/results_1.png create mode 100644 images/results_2.png create mode 100644 images/results_3.png create mode 100644 images/results_4.png delete mode 100644 requirements-rest.txt delete mode 100644 requirements.txt delete mode 100644 setup.py diff --git a/Dockerfile b/Dockerfile index 55651f7..23b2666 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,14 +1,11 @@ FROM python:3.10-slim -ADD ephemerality /ephemerality -ADD ephemerality.egg-info /ephemerality.egg-info -ADD rest /rest -ADD scripts /scripts -ADD testing /testing -ADD _version.py / +ADD dist/ephemerality-2.0.0-py3-none-any.whl /dist/ +ADD LICENSE / ADD README.md / -ADD setup.py / -RUN pip install --no-cache-dir --upgrade -e .[rest] +RUN pip install --no-cache-dir /dist/ephemerality-2.0.0-py3-none-any.whl -ENTRYPOINT ["uvicorn", "scripts.ephemerality-api:app", "--host", "0.0.0.0", "--port", "8080"] +WORKDIR /usr/local/lib/python3.10/site-packages/ephemerality + +ENTRYPOINT ["uvicorn", "rest.runner:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/README.md b/README.md index 12c399e..a039031 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ over the period of interest or are only clustered around one or several short ti Ephemerality formula is defined as follows: $$ -\varepsilon=\left(1 - \frac1\alpha \cdot \frac{core\ length}{period\ length}\right)^+ +\varepsilon_\alpha^{core}=\left(1 - \frac1\alpha \cdot \frac{core\ length}{period\ length}\right)^+ $$ Essentially, **ephemerality** is a portion of the time period occupied by non‑core activity. The core activity can be @@ -34,256 +34,276 @@ most prominent activity. Works well in combination with other cores to check whe around one or more short periods of time. ## Requirements -The code was tested to work with Python 3.10 and Numpy 1.24.2, but is expected to also run on their older versions. -FastAPI 0.110.0 and uvicorn 0.21.1 are also needed to run the ephemerality computation web-service. +The code was tested to work with Python 3.10, Numpy 1.24.2, and pydantic 2.7.1, but is expected to also run with their +older versions. +FastAPI ^0.110.2 and uvicorn ^0.22.0 are also needed to run the ephemerality computation web-service. +Matplotlib ^3.8.4 is needed for visualization of computed activity cores. -## How to run the experiments -The code can be run directly as a module `python3 -m ephemerality [args]`. There are two modes provided: a single +## How to run +Ephemerality package can be run as a standalone Python module, or used inside regular Python scripts. + +### Standalone + +The code can be run directly as a module `python3 -m ephemerality [args]`. There are two modes provided: a command line-based computation and a RESTful service. In case of the latter, there is an option to use a Docker container, either from Docker Hub (`hpaibsc/ephemerality:latest`) or built with the provided Dockerfile. -To run the module as a single command line computation use `cmd` argument: +To run the computation from the command lineuse `cmd` argument: ```shell -python3 -m ephemerality cmd ... +python3 -m ephemerality cmd [activity] [-h] [-i INPUT_FILE] [-r] [-o OUTPUT_FILE.json] [-c CORE_TYPES] [-t THRESHOLD] [--plot] +``` + +In case of activity vector of moderate size, you can enter it either as a sequence of numbers directly, or as a +comma/space separated string. Alternatively, you can save the activity vector(s) in a *.csv file (a vector per line) or +*.json file. In case of the latter, please use the following format for each input (you can have a single dictionary or +a list of ones): + +```NumPy +JSON/Python input body format + +Attributes +---------- +input_sequence : Sequence[str | float | int] + Input sequence of either activity over time bins, or timestamps to be aggregated into an activity vector. +input_type : Literal['activity', 'a', 'timestamps', 't', 'datetime', 'd'], default='a' + Format of the input sequence. +threshold : float, default=.8 + Ratio of the activity considered core. +time_format : str, optional, default="%Y-%m-%dT%H:%M:%S.%fZ" + If input type is datetime, specifies the datetime format used (refer to `strptime` format guidelines). +timezone : float, optional, default=0. + If input type is datetime, specifies the offset in hours from the UTC time. Should be within [-24, +24] range. +range : tuple[str | float | int, str | float | int], optional + If input type is timestamp or datetime, specifies the time range of the activity vector. + Defaults to (min, max) of the input timestamps. +granularity : Literal['week', 'day', 'hour'] or str, optional, default='day' + If input type is timestamp or datetime, specifies the size of time bins when converting to activity vector. + Can be specified as \'{}d\' or \'{}h\' (e.g. '2d' or '7.5h') for a custom time bin size in days or hours. +reference_name : str, optional + Will be added to the output for easier matching between inputs and outputs (besides identical sorting). ``` -To start a RESTful service use `api` argument: +The module uses uvicorn package to run a REST service. To start it use `api` argument: ```shell -python3 -m ephemerality api ... +python3 -m ephemerality api [-h] [--host HOST] [--port PORT] ... ``` -Finally, it is possible to just import the ephemerality computation function from the module: +Any additional arguments will be passed as arguments to the uvicorn call. -```Python -from ephemerality import compute_ephemerality +The web-service initialized this way accepts GET requests of the following format: -activity = [0., 0., 0., .2, .55, 0., .15, .1, 0., 0.] -threshold = 0.8 -compute_ephemerality(activity, threshold) +```http +http://{url}/ephemerality/{api_version}/all?core_types=lmrs&include_input=False ``` -Output: -``` -EphemeralitySet( - eph_left_core=0.1250000000000001, - eph_middle_core=0.5, - eph_right_core=0.2500000000000001, - eph_sorted_core=0.625, - len_left_core=7, - len_middle_core=4, - len_right_core=6, - len_sorted_core=3) -``` +* `api_version` is optional and is used for backward compatibility, it defaults to the latest API version. +* `core_types` is a string specifying the core types for which ephemerality needs to be computed. `l` for the left +core, `m` for the middle core, `r` for the right core, `s` for the sorted core, or any combination of thereof. +It defaults to all core types, `lmrs`. +* `include_input` is a boolean value specifying whether the input should be also included in the output for each +computation. +* `input_data` is a body argument in JSON format. It should contain a list of JSON dictionaries of the input type +specified above. -### Input -The script/container expect the following input arguments: - -* **Frequency vector file**. `[-i PATH, --input PATH]` _Optional_. Path to a file containing one or several arrays of -numbers in csv format (one array per line), representing temporal frequency vectors. They do not need to be normalized: -if they are not --- they will be normalized automatically. -* **Frequency vector**. _Optional_. If input file is not provided, a frequency vector is expected as a positional -argument (either comma- or space-separated). -* **Output file**. `[-o PATH, --output PATH]` _Optional_. If it is provided, the results will be written into this file -in JSON format. -* **Threshold**. `[-t FLOAT, -threshold FLOAT]` _Optional_. Threshold value for ephemerality computations. Defaults -to 0.8. -* **Print**. `[-p, --print]`. _Optional_. If output file is provided, forces the results to still be printed to stdout. - -### Output -If no output file specified or `-p` option is used, results are printed to STDOUT in [ -$\varepsilon_{orig}$ ␣ -span( $\varepsilon_{orig}$ ) ␣ -$\varepsilon_{filt}$ ␣ -span( $\varepsilon_{filt}$ ) ␣ -$\varepsilon_{sort}$ ␣ -span( $\varepsilon_{sort}$ ) -] format, one line per each line of input file (or a single line for command line input). - -If the output file was specified among the input arguments, the results will be written into that file in JSON format as -a list of dictionaries, one per input line: +The output is in JSON format. It is a list of dictionaries, with one entry per each input: -``` +```json [ { - "ephemerality_original": FLOAT, - "ephemerality_original_span": INT, - "ephemerality_filtered": FLOAT, - "ephemerality_filtered_span": INT, - "ephemerality_sorted": FLOAT, - "ephemerality_sorted_span": INT + "input": ..., + "output": { + "eph_left_core": 1.0, + "eph_middle_core": 1.0, + "eph_right_core": 1.0, + "eph_sorted_core": 1.0, + "len_left_core": 0, + "len_middle_core": 0, + "len_right_core": 0, + "len_sorted_core": 0 + } }, ... ] ``` -[//]: # (### Example) - -[//]: # () -[//]: # (Input file `test_input.csv`:) - -[//]: # (```) - -[//]: # (0.0,0.0,0.0,0.2,0.55,0.0,0.15,0.1,0.0,0.0) - -[//]: # (0,1,1.,0.0,.0) - -[//]: # (```) - -[//]: # () -[//]: # (#### Python execution:) - -[//]: # () -[//]: # (Input 1:) - -[//]: # () -[//]: # (```) - -[//]: # (python ephemerality.py -i tmp/test_input.csv -t 0.8 --output tmp/test_output.json -P) - -[//]: # (```) - -[//]: # () -[//]: # (Output 1:) - -[//]: # (```) - -[//]: # (0.1250000000000001 7 0.5 4 0.625 3) - -[//]: # (0.2500000000000001 3 0.5 2 0.5 2) - -[//]: # (```) - -[//]: # () -[//]: # (`test_output.json` content:) - -[//]: # (```) - -[//]: # ([) - -[//]: # ( {) +`input` value depends on the provided input parameters: +* If `include_input` was set to True, it will be a copy of the corresponding input dictionary. +* Otherwise it will be a string: + - `reference_name` if it was provided; + - or a zero-base counter number of the corresponding input. -[//]: # ( "ephemerality_original": 0.1250000000000001,) +#### Docker container -[//]: # ( "ephemerality_original_span": 7,) +Finally, you can also use the docker container to run the aforementioned REST service. You can either get the image +from Docker Hub: -[//]: # ( "ephemerality_filtered": 0.5,) - -[//]: # ( "ephemerality_filtered_span": 4,) - -[//]: # ( "ephemerality_sorted": 0.625,) - -[//]: # ( "ephemerality_sorted_span": 3) - -[//]: # ( },) - -[//]: # ( {) - -[//]: # ( "ephemerality_original": 0.2500000000000001,) - -[//]: # ( "ephemerality_original_span": 3,) - -[//]: # ( "ephemerality_filtered": 0.5,) - -[//]: # ( "ephemerality_filtered_span": 2,) - -[//]: # ( "ephemerality_sorted": 0.5,) - -[//]: # ( "ephemerality_sorted_span": 2) - -[//]: # ( }) - -[//]: # (]) - -[//]: # (```) - -[//]: # () -[//]: # (Input 2:) - -[//]: # () -[//]: # (```) - -[//]: # (python ephemerality.py 0.0 0.0 0.0 0.2 0.55 0.0 0.15 0.1 0.0 0.0 -t 0.5) - -[//]: # (```) - -[//]: # () -[//]: # (Output 2:) - -[//]: # (```) +```shell +docker pull hpaibsc/ephemerality:latest +``` -[//]: # (0.0 5 0.8 1 0.8 1) +Or build it from the source using the provided Dockerfile. -[//]: # (```) +The web-service will be available at `http://0.0.0.0:8080` inside of the container. -[//]: # () -[//]: # (#### Docker execution) +### Python -[//]: # (```) +Finally, it is possible to just import the ephemerality computation function from the module: -[//]: # (docker run -a STDOUT -v [PATH_TO_FOLDER]/tmp/:/tmp/ ephemerality:1.0.0 -i /tmp/test_input.csv -o /tmp/test_output.json -t 0.5 -p ) +```Python +from ephemerality import compute_ephemerality -[//]: # (```) +activity = [0., 0., 0., .2, .55, 0., .15, .1, 0., 0.] +threshold = 0.8 +compute_ephemerality(activity, threshold) +``` -[//]: # () -[//]: # (Output:) +Output: +```pycon +EphemeralitySet( + eph_left_core=0.1250000000000001, + eph_middle_core=0.5, + eph_right_core=0.2500000000000001, + eph_sorted_core=0.625, + len_left_core=7, + len_middle_core=4, + len_right_core=6, + len_sorted_core=3) +``` -[//]: # (```) +`compute_ephemerality` function has the following signature: + +```NumPy +Compute ephemerality values for given activity vector. + +This function computes ephemerality for a numeric vector using all current definitions of actiovity cores. +Alpha (desired non-ephemeral core length) can be specified with ``threshold parameter. In case not all cores are +needed, the required types can be specified in ``types``. + +Parameters +---------- +activity_vector : Sequence[float | int] + A sequence of activity values. Time bins corresponding to each value is assumed to be of equal length. Does not + need to be normalised. +threshold : float, default=0.8 + Desired non-ephemeral core length as fraction. Ephemerality is equal to 1.0 if the core length is at least ``threshold`` of + the ``activity_vector`` length. +types : str, default='lmrs' + Activity cores to be computed. A sequence of characters corresponding to core types. + 'l' for left core, 'm' for middle core, 'r' for right core, 's' for sorted core. Multiples of the same character + will be ignored. +plot : bool, default=False + Set to True to display the activity over time plot with core periods highlighted. + +Returns +------- +EphemeralitySet + Container for the computed core lengths and ephemerality values +``` -[//]: # (0.0 5 0.8 1 0.8 1) +EphemeralitySet is a simple container of the following format: + +```NumPy +Container for ephemerality and core size values. + +This class is a simple pydantic BaseModel used to store computed core lengths and corresponding ephemerality values +by core type. Values that were not computed default to None. + +Attributes +---------- +len_left_core : int, optional + Length of the left core in time bins +len_middle_core : int, optional + Length of the middle core in time bins +len_right_core : int, optional + Length of the right core in time bins +len_sorted_core : int, optional + Length of the sorted core in time bins + +eph_left_core: float, optional + Ephemerality value for the left core +eph_middle_core: float, optional + Ephemerality value for the middle core +eph_right_core: float, optional + Ephemerality value for the right core +eph_sorted_core: float, optional + Ephemerality value for the sorted core +``` -[//]: # (0.19999999999999996 2 0.6 1 0.6 1) +## Examples -[//]: # (```) +Below are several examples of activity vectors and corresponding ephemerality computation results, demonstrating +how this module can be used. All input activity vectors represent one year of activity with one day granularity. +Threshold of $\alpha=0.8$ was used for all of the examples. -[//]: # () -[//]: # (`test_output.json` content:) +### Example 1 -[//]: # (```) +![Activity vector 1](images/example_1.png) -[//]: # ([) +This vector represents a typical reaction activity to a post of any kind (e.g. text post, video, etc.). Most of the +activity is concentrated at the beginning of the observation period and quickly goes down noise afterwards. Assuming +we picked the start of the vector well (i.e. the time of posting), we will obtain the following ephemerality +computation results: -[//]: # ( {) +![Results 1](images/results_1.png) -[//]: # ( "ephemerality_original": 0.0,) +Here you can see that for the selected period ephemerality values for all cores except for the right core are high. +Essentially, ephemerality value of 0.75 in this case signifies that about a quarter of the period corresponded to +non-core activity. -[//]: # ( "ephemerality_original_span": 5,) +The exception of the right core (which is computed from the right end of the activity vector) makes sense, as to +accumulate the 80% of activity we need to go to almost the beginning of the vector. This can be interpreted as the +fact, that looking into the past from the last (e.g. current) data this activity goes essentially full period deep. +That is, this activity existed for quite a while in the past, and did not appear recently. -[//]: # ( "ephemerality_filtered": 0.8,) +### Example 2 -[//]: # ( "ephemerality_filtered_span": 1,) +![Activity vector 2](images/example_2.png) -[//]: # ( "ephemerality_sorted": 0.8,) +This activity vector has a few smaller but more gradual active periods and a big peak by its end. This produces the +following results: -[//]: # ( "ephemerality_sorted_span": 1) +![Results 2](images/results_2.png) -[//]: # ( },) +Left and middle core ephemeralities in this case are pretty low, as it takes almost all the period to accumulate the +80% of activity. The final peak was not enough to offset the previous, more gradual, activity. -[//]: # ( {) +In case of the right core, the last two peaks did contain the required amount of activity, so the ephemerality value +is significant. -[//]: # ( "ephemerality_original": 0.19999999999999996,) +Finally, as the majority of the activity is concentrated in the three peaks, the sorted ephemerality value is rather +high (albeit not close to 1, thanks to the widths of the first two peaks). -[//]: # ( "ephemerality_original_span": 2,) +### Example 3 -[//]: # ( "ephemerality_filtered": 0.6,) +![Activity vector 3](images/example_3.png) -[//]: # ( "ephemerality_filtered_span": 1,) +In this example the vector contains 4 intense and abrupt peaks of activity among the general noise, a clear indicator +of the forced activity injections. However, these peaks are spread throughout the observation period, with one being +close to the beginning of the vector, and another one to its end. -[//]: # ( "ephemerality_sorted": 0.6,) +![Results 3](images/results_3.png) -[//]: # ( "ephemerality_sorted_span": 1) +Non-sorted cores in this case do cover most of the observation period due to the spread of the peaks. However, the +sorted ephemerality value is very high, signifying that most of this activity were contained within a small number of +actual days. -[//]: # ( }) +Here we should note that it is important to look at ephemerality for all the core types. From the current results we +know that there are several well-spread short peaks of activity. If the middle core ephemerality was also high, that +would have signified that there is only one peak or a close cluster of peaks in the middle of the period. If either +the left or right core ephemerality were also high, that would have meant that this peak is closer to the left or the +right end of the vector respectively. -[//]: # (]) +### Example 4 -[//]: # (```) +![Activity vector 4](images/example_4.png) -[//]: # () -[//]: # () -[//]: # (## References) +In the final example, the activity is locally chaotic but more or less uniform over the whole period. There is a small +evolution of the trend here, but nothing unexpected. -[//]: # ([1]) +![Results 4](images/results_4.png) -[//]: # (Gnatyshak, D., Garcia-Gasulla, D., Alvarez-Napagao, S., Arjona, J., & Venturini, T. (2022). Healthy Twitter discussions? Time will tell. arXiv preprint arXiv:2203.11261) +And this uniformity is confirmed by the resulting ephemerality values which are close to 0 (it would have been 0 in +case of the same amount of activity each day). Here the slightly higher value of the sorted core ephemerality +corresponds to the general variance of the activity: the lower the local fluctuations are, the closer to 0 it will be. diff --git a/dist/ephemerality-2.0.0-py3-none-any.whl b/dist/ephemerality-2.0.0-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..fd4fbfe79de7a882e2d41bf4fd50da38a95e36b7 GIT binary patch literal 20555 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 literal 0 HcmV?d00001 diff --git a/dist/ephemerality-2.0.0.tar.gz b/dist/ephemerality-2.0.0.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c30b3710f6bcc3e80f523de3dfdb768f16584701 GIT binary patch literal 16521 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

nOvxH0$wvL8IV~;QcGmDnu{uY&rZRt#mZ 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

PC?V@#pbTv%30XmO{1(Qf~ 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 VPkT}D{Ga`;zw~-}H^UA_1^~Sdwaowk literal 0 HcmV?d00001 diff --git a/ephemerality/__init__.py b/ephemerality/__init__.py index 7d4c8c0..d682f98 100644 --- a/ephemerality/__init__.py +++ b/ephemerality/__init__.py @@ -1,5 +1,5 @@ -from .src import EphemeralitySet +from .src import EphemeralitySet, InputData from .src import compute_ephemerality -__all__ = ['compute_ephemerality', 'EphemeralitySet'] +__all__ = ['compute_ephemerality', 'InputData', 'EphemeralitySet'] diff --git a/ephemerality/__main__.py b/ephemerality/__main__.py index 54093c6..a2da2c2 100644 --- a/ephemerality/__main__.py +++ b/ephemerality/__main__.py @@ -1,6 +1,6 @@ from argparse import ArgumentParser +import importlib.metadata -from ephemerality._version import __version__ from ephemerality.scripts import init_cmd_parser, init_api_argparse PROG = "python3 -m ephemerality" @@ -13,8 +13,8 @@ def init_parser() -> ArgumentParser: description="Runs ephemerality computation module in one of the available mode." ) parser.add_argument( - "-v", "--version", action="version", - version=f"{parser.prog} version {__version__}" + "--version", action="version", + version=f'ephemerality {importlib.metadata.version("ephemerality")}' ) subparsers = parser.add_subparsers( diff --git a/ephemerality/rest/api.py b/ephemerality/rest/api.py index cc9fe61..820efbb 100644 --- a/ephemerality/rest/api.py +++ b/ephemerality/rest/api.py @@ -57,7 +57,7 @@ def process_request( return JSONResponse(content=output) -@router.post("/ephemerality/all", status_code=status.HTTP_200_OK) +@router.get("/ephemerality/all", status_code=status.HTTP_200_OK) async def compute_all_ephemeralities_default_version( input_data: list[InputData], core_types: Annotated[ @@ -74,7 +74,7 @@ async def compute_all_ephemeralities_default_version( ) -@router.post("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) +@router.get("/ephemerality/{api_version}/all", status_code=status.HTTP_200_OK) async def compute_all_ephemeralities( input_data: list[InputData], api_version: str, diff --git a/ephemerality/rest/api_versions/__init__.py b/ephemerality/rest/api_versions/__init__.py index 22e57f2..b886d2d 100644 --- a/ephemerality/rest/api_versions/__init__.py +++ b/ephemerality/rest/api_versions/__init__.py @@ -3,8 +3,8 @@ __all__ = [ - 'AbstractRestApi', - 'RestAPI11' + AbstractRestApi, + RestAPI11 ] diff --git a/ephemerality/rest/api_versions/api_template.py b/ephemerality/rest/api_versions/api_template.py index 40f345e..8c95d06 100644 --- a/ephemerality/rest/api_versions/api_template.py +++ b/ephemerality/rest/api_versions/api_template.py @@ -10,9 +10,9 @@ class AbstractRestApi(ABC): def version() -> str | None: return None + @staticmethod @abstractmethod - def get_ephemerality(self, - input_vector: Sequence[float], + def get_ephemerality(input_vector: Sequence[float], threshold: Annotated[float, Query(gt=0., le=1.)], types: Annotated[str, Query(Query(min_length=1, max_length=4, regex="^[lmrs]+$"))] ) -> EphemeralitySet: diff --git a/ephemerality/scripts/ephemerality_api.py b/ephemerality/scripts/ephemerality_api.py index 4c27170..5821cc2 100644 --- a/ephemerality/scripts/ephemerality_api.py +++ b/ephemerality/scripts/ephemerality_api.py @@ -1,12 +1,12 @@ +import argparse from argparse import ArgumentParser, Namespace from subprocess import call -from ephemerality.rest import set_test_mode - def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: - parser.usage = "%(prog)s [-h] [--host HOST] [--port PORT] [--test] ..." - parser.description = "Start a REST web service to compute ephemerality computations on requests." + parser.usage = "%(prog)s [-h] [--host HOST] [--port PORT] ..." + parser.description = ("Start a REST web service to compute ephemerality computations on requests. Any additional " + "arguments will be passed to the uvicorn service initialisation call.") parser.add_argument( "--host", action="store", default="127.0.0.1", help="Bind socket to this host. Defaults to \"127.0.0.1\"." @@ -16,9 +16,8 @@ def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: help="Bind to a socket with this port. Defaults to 8080." ) parser.add_argument( - "--test", action="store_true", - help="Run the web service in a mode that allows to process requests to evaluate time and RAM performance of " - "the module (can be computationally expensive!)." + "uvicorn_args", nargs=argparse.REMAINDER, + help="Arguments to be passed to uvicorn." ) parser.set_defaults( func=exec_start_service_call @@ -26,10 +25,12 @@ def init_api_argparse(parser: ArgumentParser) -> ArgumentParser: return parser -def start_service(host: str = "127.0.0.1", port: int = 8080, test_mode: bool = False) -> None: - set_test_mode(test_mode) - call(['uvicorn', 'ephemerality.rest.runner:app', '--host', host, '--port', str(port)]) +def start_service(host: str = "127.0.0.1", port: int = 8080, uvicorn_args: list | None = None) -> None: + call_cmd = ['uvicorn', 'ephemerality.rest.runner:app', '--host', host, '--port', str(port)] + if uvicorn_args: + call_cmd.extend(uvicorn_args) + call(call_cmd) def exec_start_service_call(input_args: Namespace) -> None: - start_service(host=input_args.host, port=input_args.port, test_mode=input_args.test) + start_service(host=input_args.host, port=input_args.port, uvicorn_args=input_args.uvicorn_args) diff --git a/ephemerality/scripts/ephemerality_cmd.py b/ephemerality/scripts/ephemerality_cmd.py index e128c82..9fde6bf 100644 --- a/ephemerality/scripts/ephemerality_cmd.py +++ b/ephemerality/scripts/ephemerality_cmd.py @@ -1,16 +1,14 @@ import json import sys -import time -from argparse import ArgumentParser, Namespace, SUPPRESS +from argparse import ArgumentParser, Namespace from pathlib import Path -from memory_profiler import memory_usage import numpy as np from ephemerality.src import compute_ephemerality, process_input, ProcessedData def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: - parser.usage = "%(prog)s [activity] [-h] [-i INPUT_FILE] [-r] [-o OUTPUT_FILE.json] [-t THRESHOLD]..." + parser.usage = "%(prog)s [activity] [-h] [-i INPUT_FILE] [-r] [-o OUTPUT_FILE.json] [-c CORE_TYPES] [-t THRESHOLD] [--plot]..." parser.description = "Calculate ephemerality for a given activity vector or a set of timestamps." parser.add_argument( "-p", "--print", action="store_true", @@ -36,19 +34,20 @@ def init_cmd_parser(parser: ArgumentParser) -> ArgumentParser: "level. If negative, will output results as a single line. Defaults to -1." ) parser.add_argument( - "-t", "--threshold", action="store", type=float, default=0.8, - help="Threshold value for ephemerality computations in case of CSV input. Defaults to 0.8." + "-c", "--core_types", action="store", type=str, default="lmrs", + help="Specify core types to be computed. \"l\" for left core, \"m\" for middle core, \"r\" for right core, " + "\"s\" for sorted core, or any combination of thereof. Default to \"lmrs\" for all 4 core types. " ) parser.add_argument( - "--test_time_reps", action="store", type=int, default=0, - help=SUPPRESS + "-t", "--threshold", action="store", type=float, default=0.8, + help="Threshold value for ephemerality computations in case of CSV input. Defaults to 0.8." ) parser.add_argument( - "--test_ram_reps", action="store", type=int, default=0, - help=SUPPRESS + "--plot", action="store_true", + help="Visualize requested core types on the activity vector plot." ) parser.add_argument( - 'activity', type=float, + 'activity', help='Activity vector (if the input file is not specified)', nargs='*' ) @@ -82,41 +81,30 @@ def exec_cmd_compute_call(input_args: Namespace) -> None: name="cmd-input", activity=np.array(input_args.activity[0].split(' '), dtype=float), threshold=float(input_args.threshold))) - else: + elif ',' in input_args.activity[0]: input_cases.append( ProcessedData( name="cmd-input", activity=np.array(input_args.activity[0].split(','), dtype=float), threshold=float(input_args.threshold))) + else: + input_cases.append( + ProcessedData( + name="cmd-input", + activity=np.array([input_args.activity[0]], dtype=float), + threshold=float(input_args.threshold))) else: sys.exit('No input provided!') results = {} - if input_args.test_time_reps > 0 or input_args.test_ram_reps > 0: - if input_args.test_time_reps: - for input_case in input_cases: - results["time"] = dict() - times = [] - for i in range(input_args.test_time_reps): - start_time = time.time() - compute_ephemerality(activity_vector=input_case.activity, threshold=input_case.threshold).dict() - times.append(time.time() - start_time) - results["time"][input_case.name] = times - if input_args.test_ram_reps: - for input_case in input_cases: - results["RAM"] = dict() - rams = [] - for i in range(input_args.test_ram_reps): - rams.append(memory_usage( - (compute_ephemerality, [], {"activity_vector": input_case.activity, "threshold": input_case.threshold}), - max_usage=True - )) - results["RAM"][input_case.name] = rams - else: - for input_case in input_cases: - results[input_case.name] = compute_ephemerality(activity_vector=input_case.activity, - threshold=input_case.threshold).dict() + for input_case in input_cases: + results[input_case.name] = compute_ephemerality(activity_vector=input_case.activity, + threshold=input_case.threshold, + types=input_args.core_types, + plot=input_args.plot).dict() + if len(results) == 1: + results = results.popitem()[1] output_indent = input_args.output_indent if input_args.output_indent >= 0 else None if input_args.output: diff --git a/ephemerality/src/data_processing.py b/ephemerality/src/data_processing.py index b3dd170..c87bf13 100644 --- a/ephemerality/src/data_processing.py +++ b/ephemerality/src/data_processing.py @@ -3,9 +3,10 @@ from dataclasses import dataclass from datetime import datetime, timezone, timedelta from pathlib import Path -from typing import Sequence +from typing import Sequence, Literal import numpy as np +from numpy.typing import NDArray from pydantic import BaseModel SECONDS_WEEK = 604800. @@ -15,23 +16,49 @@ class InputData(BaseModel): """ - POST request body format + GET request body format + + Attributes + ---------- + input_sequence : Sequence[str | float | int] + Input sequence of either activity over time bins, or timestamps to be aggregated into an activity vector. + input_type : Literal['activity', 'a', 'timestamps', 't', 'datetime', 'd'], default='a' + Format of the input sequence. + threshold : float, default=.8 + Ratio of the activity considered core. + time_format : str, optional, default="%Y-%m-%dT%H:%M:%S.%fZ" + If input type is datetime, specifies the datetime format used (refer to `strptime` format guidelines). + timezone : float, optional, default=0. + If input type is datetime, specifies the offset in hours from the UTC time. Should be within [-24, +24] range. + range : tuple[str | float | int, str | float | int], optional + If input type is timestamp or datetime, specifies the time range of the activity vector. + Defaults to (min, max) of the input timestamps. + granularity : Literal['week', 'day', 'hour'] or str, optional, default='day' + If input type is timestamp or datetime, specifies the size of time bins when converting to activity vector. + Can be specified as \'{}d\' or \'{}h\' (e.g. '2d' or '7.5h') for a custom time bin size in days or hours. + reference_name : str, optional + Will be added to the output for easier matching between inputs and outputs (besides identical sorting). """ - input_sequence: list[str] - input_type: str = 'a' # 'activity' | 'a' | 'timestamps' | 't' | 'datetime' | 'd' - threshold: float = 0.8 - time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" # used only if input_type == 'datetime' | 'd'. Should be in strptime format - timezone: float = 0. # used only if input_type == 'datetime' | 'd'. Offset in hours from the UTC time. Should be within [-24, +24] range. - range: None | tuple[ - str, str] = None # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd', defaults to (min(input), max(input)) - granularity: None | str = 'day' # used only if input_type == 'timestamps' | 't' | 'datetime' | 'd'. {'week', 'day', 'hour', '_d', '_h'} + input_sequence: Sequence[str | float | int] + input_type: Literal['activity', 'a', 'timestamps', 't', 'datetime', 'd'] = 'a' + threshold: float = .8 + time_format: str = "%Y-%m-%dT%H:%M:%S.%fZ" + timezone: float = 0. + range: None | tuple[str | float | int, str | float | int] = None + granularity: Literal['week', 'day', 'hour'] | str = 'day' reference_name: str = "" + def __init__(self, **kwargs): + kwargs['input_sequence'] = [str(item) for item in kwargs['input_sequence']] + if 'range' in kwargs and kwargs['range'] is not None: + kwargs['range'] = (str(kwargs['range'][0]), str(kwargs['range'][1])) + super().__init__(**kwargs) + @dataclass class ProcessedData: name: str - activity: np.ndarray[float] + activity: NDArray[float] threshold: float = 0.8 @@ -145,7 +172,7 @@ def process_formatted_data(input_data: InputData) -> ProcessedData: raise ValueError("Wrong \"input_type\" value!") -def process_csv(path: Path) -> list[np.ndarray[float]]: +def process_csv(path: Path) -> list[NDArray[float]]: output = [] with open(path, 'r') as f: for line in f: @@ -156,7 +183,7 @@ def process_csv(path: Path) -> list[np.ndarray[float]]: def timestamps_to_activity(timestamps: Sequence[float | int | str], ts_range: None | tuple[float | int | str, float | int | str] = None, - granularity: str = 'day') -> np.ndarray[float]: + granularity: str = 'day') -> NDArray[float]: if not isinstance(timestamps, np.ndarray) or timestamps.dtype != float: timestamps = np.array(timestamps, dtype=float) if ts_range is None: diff --git a/ephemerality/src/ephemerality_computation.py b/ephemerality/src/ephemerality_computation.py index b49d37c..f8bbb09 100644 --- a/ephemerality/src/ephemerality_computation.py +++ b/ephemerality/src/ephemerality_computation.py @@ -75,11 +75,11 @@ def _init_fig(core_types: set[str]) -> tuple[Figure, list[Axes]]: return fig, axes -def _annotate_ax(ax: Axes, x_len: int, core_type: str, core_length: int, ephemerality: float) -> Axes: +def _annotate_ax(ax: Axes, x_len: int, core_type: str, core_length: int, ephemerality: float, threshold: float) -> Axes: ax.set_xlim((0, x_len)) ax.set_xlabel('Time') ax.set_ylabel('Normalized activity') - ax.set_title(rf'{core_type} core (length {core_length}), $\varepsilon={np.round(ephemerality, 3)}$') + ax.set_title(rf'{core_type} core (length {core_length}), $\varepsilon_{{{threshold}}}^{core_type[0].lower()}={np.round(ephemerality, 3)}$') return ax @@ -250,7 +250,7 @@ def compute_ephemerality( A sequence of activity values. Time bins corresponding to each value is assumed to be of equal length. Does not need to be normalised. threshold : float, default=0.8 - Desired non-ephemeral core length. Ephemerality is equal to 1. if the core length is at least ``threshold`` of + Desired non-ephemeral core length as fraction. Ephemerality is equal to 1.0 if the core length is at least ``threshold`` of the ``activity_vector`` length. types : str, default='lmrs' Activity cores to be computed. A sequence of characters corresponding to core types. @@ -339,13 +339,13 @@ def compute_ephemerality( for i, subplot_type in enumerate(subplot_types): match subplot_type: case 'l': - _annotate_ax(axes[i], len_range, 'Left', ephemeralities.len_left_core, ephemeralities.eph_left_core) + _annotate_ax(axes[i], len_range, 'Left', ephemeralities.len_left_core, ephemeralities.eph_left_core, threshold) case 'm': - _annotate_ax(axes[i], len_range, 'Middle', ephemeralities.len_middle_core, ephemeralities.eph_middle_core) + _annotate_ax(axes[i], len_range, 'Middle', ephemeralities.len_middle_core, ephemeralities.eph_middle_core, threshold) case 'r': - _annotate_ax(axes[i], len_range, 'Right', ephemeralities.len_right_core, ephemeralities.eph_right_core) + _annotate_ax(axes[i], len_range, 'Right', ephemeralities.len_right_core, ephemeralities.eph_right_core, threshold) case 's': - _annotate_ax(axes[i], len_range, 'Sorted', ephemeralities.len_sorted_core, ephemeralities.eph_sorted_core) + _annotate_ax(axes[i], len_range, 'Sorted', ephemeralities.len_sorted_core, ephemeralities.eph_sorted_core, threshold) fig.tight_layout() fig.show() diff --git a/ephemerality/src/utils.py b/ephemerality/src/utils.py index 84cbb54..5063891 100644 --- a/ephemerality/src/utils.py +++ b/ephemerality/src/utils.py @@ -46,16 +46,25 @@ def __eq__(self, other) -> bool: self.len_middle_core != other.len_middle_core or \ self.len_right_core != other.len_right_core or \ self.len_sorted_core != other.len_sorted_core or \ - not np.isclose(self.eph_left_core, other.eph_left_core) or \ - not np.isclose(self.eph_middle_core, other.eph_middle_core) or \ - not np.isclose(self.eph_right_core, other.eph_right_core) or \ - not np.isclose(self.eph_sorted_core, other.eph_sorted_core): + not self._cmp_float_none(self.eph_left_core, other.eph_left_core) or \ + not self._cmp_float_none(self.eph_middle_core, other.eph_middle_core) or \ + not self._cmp_float_none(self.eph_right_core, other.eph_right_core) or \ + not self._cmp_float_none(self.eph_sorted_core, other.eph_sorted_core): return False else: return True else: return False + @staticmethod + def _cmp_float_none(value1: float | None, value2: float | None) -> bool: + if value1 is None and value2 is None: + return True + elif value1 is None or value2 is None: + return False + else: + return np.isclose(value1, value2) + def __str__(self) -> str: values = ', '.join([f'{pair[0]}={pair[1]}' for pair in sorted(list(self.dict(exclude_none=True).items()), key=lambda x: x[0])]) return f'{self.__class__.__name__}({values})' diff --git a/images/example_1.png b/images/example_1.png new file mode 100644 index 0000000000000000000000000000000000000000..53d5596d7a7e43e90793346d322ce71ccbf3feda GIT binary patch literal 16014 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 Way%b=atFJVBzacmOp@5;+y4iy!8jNI literal 0 HcmV?d00001 diff --git a/images/example_3.png b/images/example_3.png new file mode 100644 index 0000000000000000000000000000000000000000..0aef215ceb2ae9d0705839e1326d748e6aa9f609 GIT binary patch literal 12572 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 GeE$!jQwUf9 literal 0 HcmV?d00001 diff --git a/images/example_4.png b/images/example_4.png new file mode 100644 index 0000000000000000000000000000000000000000..84149f71eaeb8435828ed2f7d243b63ef921ac84 GIT binary patch literal 13693 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�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 literal 0 HcmV?d00001 diff --git a/images/results_2.png b/images/results_2.png new file mode 100644 index 0000000000000000000000000000000000000000..d07fef7097cb3cb28a5bd356241761a21d9aa228 GIT binary patch literal 41776 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 H{hR+E$5a|t literal 0 HcmV?d00001 diff --git a/images/results_3.png b/images/results_3.png new file mode 100644 index 0000000000000000000000000000000000000000..8db530c90f33191260b18fa0351f1973f71b759d GIT binary patch literal 43562 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 DF(r2Q literal 0 HcmV?d00001 diff --git a/images/results_4.png b/images/results_4.png new file mode 100644 index 0000000000000000000000000000000000000000..c8e4238843a51c506e4f5c02dbfdb135e6ee6402 GIT binary patch literal 51908 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℞-CvuIcv;7D_-t>BDsMFugG6_K#vYc}Z9G>a*Hx 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 Pz{mBg>WaCSO@03Ztii?a literal 0 HcmV?d00001 diff --git a/poetry.lock b/poetry.lock index dc4d364..d0a8124 100644 --- a/poetry.lock +++ b/poetry.lock @@ -34,369 +34,18 @@ test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypo trio = ["trio (>=0.23)"] [[package]] -name = "appnope" -version = "0.1.4" -description = "Disable App Nap on macOS >= 10.9" -optional = false -python-versions = ">=3.6" -files = [ - {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, - {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, -] - -[[package]] -name = "argon2-cffi" -version = "23.1.0" -description = "Argon2 for Python" -optional = false -python-versions = ">=3.7" -files = [ - {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, - {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, -] - -[package.dependencies] -argon2-cffi-bindings = "*" - -[package.extras] -dev = ["argon2-cffi[tests,typing]", "tox (>4)"] -docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] -tests = ["hypothesis", "pytest"] -typing = ["mypy"] - -[[package]] -name = "argon2-cffi-bindings" -version = "21.2.0" -description = "Low-level CFFI bindings for Argon2" -optional = false -python-versions = ">=3.6" -files = [ - {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, - {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, -] - -[package.dependencies] -cffi = ">=1.0.1" - -[package.extras] -dev = ["cogapp", "pre-commit", "pytest", "wheel"] -tests = ["pytest"] - -[[package]] -name = "arrow" -version = "1.3.0" -description = "Better dates & times for Python" -optional = false -python-versions = ">=3.8" -files = [ - {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, - {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, -] - -[package.dependencies] -python-dateutil = ">=2.7.0" -types-python-dateutil = ">=2.8.10" - -[package.extras] -doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] -test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] - -[[package]] -name = "asttokens" -version = "2.4.1" -description = "Annotate AST trees with source code positions" -optional = false -python-versions = "*" -files = [ - {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, - {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, -] - -[package.dependencies] -six = ">=1.12.0" - -[package.extras] -astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] -test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] - -[[package]] -name = "async-lru" -version = "2.0.4" -description = "Simple LRU cache for asyncio" -optional = false -python-versions = ">=3.8" -files = [ - {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, - {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, -] - -[package.dependencies] -typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} - -[[package]] -name = "attrs" -version = "23.2.0" -description = "Classes Without Boilerplate" -optional = false -python-versions = ">=3.7" -files = [ - {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, - {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, -] - -[package.extras] -cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] -dev = ["attrs[tests]", "pre-commit"] -docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] -tests = ["attrs[tests-no-zope]", "zope-interface"] -tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] -tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] - -[[package]] -name = "babel" -version = "2.14.0" -description = "Internationalization utilities" +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" optional = false python-versions = ">=3.7" files = [ - {file = "Babel-2.14.0-py3-none-any.whl", hash = "sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287"}, - {file = "Babel-2.14.0.tar.gz", hash = "sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363"}, -] - -[package.extras] -dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] - -[[package]] -name = "beautifulsoup4" -version = "4.12.3" -description = "Screen-scraping library" -optional = false -python-versions = ">=3.6.0" -files = [ - {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, - {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, -] - -[package.dependencies] -soupsieve = ">1.2" - -[package.extras] -cchardet = ["cchardet"] -chardet = ["chardet"] -charset-normalizer = ["charset-normalizer"] -html5lib = ["html5lib"] -lxml = ["lxml"] - -[[package]] -name = "bleach" -version = "6.1.0" -description = "An easy safelist-based HTML-sanitizing tool." -optional = false -python-versions = ">=3.8" -files = [ - {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, - {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, -] - -[package.dependencies] -six = ">=1.9.0" -webencodings = "*" - -[package.extras] -css = ["tinycss2 (>=1.1.0,<1.3)"] - -[[package]] -name = "certifi" -version = "2024.2.2" -description = "Python package for providing Mozilla's CA Bundle." -optional = false -python-versions = ">=3.6" -files = [ - {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"}, - {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, -] - -[[package]] -name = "cffi" -version = "1.16.0" -description = "Foreign Function Interface for Python calling C code." -optional = false -python-versions = ">=3.8" -files = [ - {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, - {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, - {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, - {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, - {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, - {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, - {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, - {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, - {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, - {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, - {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, - {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, - {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, - {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, - {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, - {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, - {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, - {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, - {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, - {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, - {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, - {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, - {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, - {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, - {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, - {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, - {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, ] [package.dependencies] -pycparser = "*" - -[[package]] -name = "charset-normalizer" -version = "3.3.2" -description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." -optional = false -python-versions = ">=3.7.0" -files = [ - {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, - {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, - {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, - {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, - {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, - {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, - {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, - {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, -] +colorama = {version = "*", markers = "platform_system == \"Windows\""} [[package]] name = "colorama" @@ -409,23 +58,6 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] -[[package]] -name = "comm" -version = "0.2.2" -description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." -optional = false -python-versions = ">=3.8" -files = [ - {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, - {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, -] - -[package.dependencies] -traitlets = ">=4" - -[package.extras] -test = ["pytest"] - [[package]] name = "contourpy" version = "1.2.1" @@ -504,59 +136,6 @@ files = [ docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] tests = ["pytest", "pytest-cov", "pytest-xdist"] -[[package]] -name = "debugpy" -version = "1.8.1" -description = "An implementation of the Debug Adapter Protocol for Python" -optional = false -python-versions = ">=3.8" -files = [ - {file = "debugpy-1.8.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3bda0f1e943d386cc7a0e71bfa59f4137909e2ed947fb3946c506e113000f741"}, - {file = "debugpy-1.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dda73bf69ea479c8577a0448f8c707691152e6c4de7f0c4dec5a4bc11dee516e"}, - {file = "debugpy-1.8.1-cp310-cp310-win32.whl", hash = "sha256:3a79c6f62adef994b2dbe9fc2cc9cc3864a23575b6e387339ab739873bea53d0"}, - {file = "debugpy-1.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:7eb7bd2b56ea3bedb009616d9e2f64aab8fc7000d481faec3cd26c98a964bcdd"}, - {file = "debugpy-1.8.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:016a9fcfc2c6b57f939673c874310d8581d51a0fe0858e7fac4e240c5eb743cb"}, - {file = "debugpy-1.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd97ed11a4c7f6d042d320ce03d83b20c3fb40da892f994bc041bbc415d7a099"}, - {file = "debugpy-1.8.1-cp311-cp311-win32.whl", hash = "sha256:0de56aba8249c28a300bdb0672a9b94785074eb82eb672db66c8144fff673146"}, - {file = "debugpy-1.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a9fe0829c2b854757b4fd0a338d93bc17249a3bf69ecf765c61d4c522bb92a8"}, - {file = "debugpy-1.8.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3ebb70ba1a6524d19fa7bb122f44b74170c447d5746a503e36adc244a20ac539"}, - {file = "debugpy-1.8.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2e658a9630f27534e63922ebf655a6ab60c370f4d2fc5c02a5b19baf4410ace"}, - {file = "debugpy-1.8.1-cp312-cp312-win32.whl", hash = "sha256:caad2846e21188797a1f17fc09c31b84c7c3c23baf2516fed5b40b378515bbf0"}, - {file = "debugpy-1.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:edcc9f58ec0fd121a25bc950d4578df47428d72e1a0d66c07403b04eb93bcf98"}, - {file = "debugpy-1.8.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:7a3afa222f6fd3d9dfecd52729bc2e12c93e22a7491405a0ecbf9e1d32d45b39"}, - {file = "debugpy-1.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d915a18f0597ef685e88bb35e5d7ab968964b7befefe1aaea1eb5b2640b586c7"}, - {file = "debugpy-1.8.1-cp38-cp38-win32.whl", hash = "sha256:92116039b5500633cc8d44ecc187abe2dfa9b90f7a82bbf81d079fcdd506bae9"}, - {file = "debugpy-1.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:e38beb7992b5afd9d5244e96ad5fa9135e94993b0c551ceebf3fe1a5d9beb234"}, - {file = "debugpy-1.8.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:bfb20cb57486c8e4793d41996652e5a6a885b4d9175dd369045dad59eaacea42"}, - {file = "debugpy-1.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efd3fdd3f67a7e576dd869c184c5dd71d9aaa36ded271939da352880c012e703"}, - {file = "debugpy-1.8.1-cp39-cp39-win32.whl", hash = "sha256:58911e8521ca0c785ac7a0539f1e77e0ce2df753f786188f382229278b4cdf23"}, - {file = "debugpy-1.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:6df9aa9599eb05ca179fb0b810282255202a66835c6efb1d112d21ecb830ddd3"}, - {file = "debugpy-1.8.1-py2.py3-none-any.whl", hash = "sha256:28acbe2241222b87e255260c76741e1fbf04fdc3b6d094fcf57b6c6f75ce1242"}, - {file = "debugpy-1.8.1.zip", hash = "sha256:f696d6be15be87aef621917585f9bb94b1dc9e8aced570db1b8a6fc14e8f9b42"}, -] - -[[package]] -name = "decorator" -version = "5.1.1" -description = "Decorators for Humans" -optional = false -python-versions = ">=3.5" -files = [ - {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, - {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, -] - -[[package]] -name = "defusedxml" -version = "0.7.1" -description = "XML bomb protection for Python stdlib modules" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, - {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, -] - [[package]] name = "exceptiongroup" version = "1.2.1" @@ -572,32 +151,23 @@ files = [ test = ["pytest (>=6)"] [[package]] -name = "executing" -version = "2.0.1" -description = "Get the currently executing AST node of a frame, and other information" +name = "fastapi" +version = "0.110.3" +description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production" optional = false -python-versions = ">=3.5" +python-versions = ">=3.8" files = [ - {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, - {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, + {file = "fastapi-0.110.3-py3-none-any.whl", hash = "sha256:fd7600612f755e4050beb74001310b5a7e1796d149c2ee363124abdfa0289d32"}, + {file = "fastapi-0.110.3.tar.gz", hash = "sha256:555700b0159379e94fdbfc6bb66a0f1c43f4cf7060f25239af3d84b63a656626"}, ] -[package.extras] -tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] - -[[package]] -name = "fastjsonschema" -version = "2.19.1" -description = "Fastest Python implementation of JSON schema" -optional = false -python-versions = "*" -files = [ - {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, - {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, -] +[package.dependencies] +pydantic = ">=1.7.4,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0 || >2.0.0,<2.0.1 || >2.0.1,<2.1.0 || >2.1.0,<3.0.0" +starlette = ">=0.37.2,<0.38.0" +typing-extensions = ">=4.8.0" [package.extras] -devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] +all = ["email_validator (>=2.0.0)", "httpx (>=0.23.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=2.11.2)", "orjson (>=3.2.1)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.7)", "pyyaml (>=5.3.1)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0)", "uvicorn[standard] (>=0.12.0)"] [[package]] name = "fonttools" @@ -664,17 +234,6 @@ ufo = ["fs (>=2.2.0,<3)"] unicode = ["unicodedata2 (>=15.1.0)"] woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] -[[package]] -name = "fqdn" -version = "1.5.1" -description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" -optional = false -python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" -files = [ - {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, - {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, -] - [[package]] name = "h11" version = "0.14.0" @@ -686,51 +245,6 @@ files = [ {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, ] -[[package]] -name = "httpcore" -version = "1.0.5" -description = "A minimal low-level HTTP client." -optional = false -python-versions = ">=3.8" -files = [ - {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, - {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, -] - -[package.dependencies] -certifi = "*" -h11 = ">=0.13,<0.15" - -[package.extras] -asyncio = ["anyio (>=4.0,<5.0)"] -http2 = ["h2 (>=3,<5)"] -socks = ["socksio (==1.*)"] -trio = ["trio (>=0.22.0,<0.26.0)"] - -[[package]] -name = "httpx" -version = "0.27.0" -description = "The next generation HTTP client." -optional = false -python-versions = ">=3.8" -files = [ - {file = "httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5"}, - {file = "httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5"}, -] - -[package.dependencies] -anyio = "*" -certifi = "*" -httpcore = "==1.*" -idna = "*" -sniffio = "*" - -[package.extras] -brotli = ["brotli", "brotlicffi"] -cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"] -http2 = ["h2 (>=3,<5)"] -socks = ["socksio (==1.*)"] - [[package]] name = "idna" version = "3.7" @@ -743,476 +257,9 @@ files = [ ] [[package]] -name = "ipykernel" -version = "6.29.4" -description = "IPython Kernel for Jupyter" -optional = false -python-versions = ">=3.8" -files = [ - {file = "ipykernel-6.29.4-py3-none-any.whl", hash = "sha256:1181e653d95c6808039c509ef8e67c4126b3b3af7781496c7cbfb5ed938a27da"}, - {file = "ipykernel-6.29.4.tar.gz", hash = "sha256:3d44070060f9475ac2092b760123fadf105d2e2493c24848b6691a7c4f42af5c"}, -] - -[package.dependencies] -appnope = {version = "*", markers = "platform_system == \"Darwin\""} -comm = ">=0.1.1" -debugpy = ">=1.6.5" -ipython = ">=7.23.1" -jupyter-client = ">=6.1.12" -jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" -matplotlib-inline = ">=0.1" -nest-asyncio = "*" -packaging = "*" -psutil = "*" -pyzmq = ">=24" -tornado = ">=6.1" -traitlets = ">=5.4.0" - -[package.extras] -cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] -pyqt5 = ["pyqt5"] -pyside6 = ["pyside6"] -test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.23.5)", "pytest-cov", "pytest-timeout"] - -[[package]] -name = "ipython" -version = "8.23.0" -description = "IPython: Productive Interactive Computing" -optional = false -python-versions = ">=3.10" -files = [ - {file = "ipython-8.23.0-py3-none-any.whl", hash = "sha256:07232af52a5ba146dc3372c7bf52a0f890a23edf38d77caef8d53f9cdc2584c1"}, - {file = "ipython-8.23.0.tar.gz", hash = "sha256:7468edaf4f6de3e1b912e57f66c241e6fd3c7099f2ec2136e239e142e800274d"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "sys_platform == \"win32\""} -decorator = "*" -exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} -jedi = ">=0.16" -matplotlib-inline = "*" -pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} -prompt-toolkit = ">=3.0.41,<3.1.0" -pygments = ">=2.4.0" -stack-data = "*" -traitlets = ">=5.13.0" -typing-extensions = {version = "*", markers = "python_version < \"3.12\""} - -[package.extras] -all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] -black = ["black"] -doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"] -kernel = ["ipykernel"] -matplotlib = ["matplotlib"] -nbconvert = ["nbconvert"] -nbformat = ["nbformat"] -notebook = ["ipywidgets", "notebook"] -parallel = ["ipyparallel"] -qtconsole = ["qtconsole"] -test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"] -test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] - -[[package]] -name = "ipywidgets" -version = "8.1.2" -description = "Jupyter interactive widgets" -optional = false -python-versions = ">=3.7" -files = [ - {file = "ipywidgets-8.1.2-py3-none-any.whl", hash = "sha256:bbe43850d79fb5e906b14801d6c01402857996864d1e5b6fa62dd2ee35559f60"}, - {file = "ipywidgets-8.1.2.tar.gz", hash = "sha256:d0b9b41e49bae926a866e613a39b0f0097745d2b9f1f3dd406641b4a57ec42c9"}, -] - -[package.dependencies] -comm = ">=0.1.3" -ipython = ">=6.1.0" -jupyterlab-widgets = ">=3.0.10,<3.1.0" -traitlets = ">=4.3.1" -widgetsnbextension = ">=4.0.10,<4.1.0" - -[package.extras] -test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] - -[[package]] -name = "isoduration" -version = "20.11.0" -description = "Operations with ISO 8601 durations" -optional = false -python-versions = ">=3.7" -files = [ - {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, - {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, -] - -[package.dependencies] -arrow = ">=0.15.0" - -[[package]] -name = "jedi" -version = "0.19.1" -description = "An autocompletion tool for Python that can be used for text editors." -optional = false -python-versions = ">=3.6" -files = [ - {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, - {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, -] - -[package.dependencies] -parso = ">=0.8.3,<0.9.0" - -[package.extras] -docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] -qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] -testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] - -[[package]] -name = "jinja2" -version = "3.1.3" -description = "A very fast and expressive template engine." -optional = false -python-versions = ">=3.7" -files = [ - {file = "Jinja2-3.1.3-py3-none-any.whl", hash = "sha256:7d6d50dd97d52cbc355597bd845fabfbac3f551e1f99619e39a35ce8c370b5fa"}, - {file = "Jinja2-3.1.3.tar.gz", hash = "sha256:ac8bd6544d4bb2c9792bf3a159e80bba8fda7f07e81bc3aed565432d5925ba90"}, -] - -[package.dependencies] -MarkupSafe = ">=2.0" - -[package.extras] -i18n = ["Babel (>=2.7)"] - -[[package]] -name = "json5" -version = "0.9.25" -description = "A Python implementation of the JSON5 data format." -optional = false -python-versions = ">=3.8" -files = [ - {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, - {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, -] - -[[package]] -name = "jsonpointer" -version = "2.4" -description = "Identify specific nodes in a JSON document (RFC 6901)" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*" -files = [ - {file = "jsonpointer-2.4-py2.py3-none-any.whl", hash = "sha256:15d51bba20eea3165644553647711d150376234112651b4f1811022aecad7d7a"}, - {file = "jsonpointer-2.4.tar.gz", hash = "sha256:585cee82b70211fa9e6043b7bb89db6e1aa49524340dde8ad6b63206ea689d88"}, -] - -[[package]] -name = "jsonschema" -version = "4.21.1" -description = "An implementation of JSON Schema validation for Python" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jsonschema-4.21.1-py3-none-any.whl", hash = "sha256:7996507afae316306f9e2290407761157c6f78002dcf7419acb99822143d1c6f"}, - {file = "jsonschema-4.21.1.tar.gz", hash = "sha256:85727c00279f5fa6bedbe6238d2aa6403bedd8b4864ab11207d07df3cc1b2ee5"}, -] - -[package.dependencies] -attrs = ">=22.2.0" -fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} -jsonschema-specifications = ">=2023.03.6" -referencing = ">=0.28.4" -rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} -rpds-py = ">=0.7.1" -uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -webcolors = {version = ">=1.11", optional = true, markers = "extra == \"format-nongpl\""} - -[package.extras] -format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] -format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] - -[[package]] -name = "jsonschema-specifications" -version = "2023.12.1" -description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, - {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, -] - -[package.dependencies] -referencing = ">=0.31.0" - -[[package]] -name = "jupyter" -version = "1.0.0" -description = "Jupyter metapackage. Install all the Jupyter components in one go." -optional = false -python-versions = "*" -files = [ - {file = "jupyter-1.0.0-py2.py3-none-any.whl", hash = "sha256:5b290f93b98ffbc21c0c7e749f054b3267782166d72fa5e3ed1ed4eaf34a2b78"}, - {file = "jupyter-1.0.0.tar.gz", hash = "sha256:d9dc4b3318f310e34c82951ea5d6683f67bed7def4b259fafbfe4f1beb1d8e5f"}, - {file = "jupyter-1.0.0.zip", hash = "sha256:3e1f86076bbb7c8c207829390305a2b1fe836d471ed54be66a3b8c41e7f46cc7"}, -] - -[package.dependencies] -ipykernel = "*" -ipywidgets = "*" -jupyter-console = "*" -nbconvert = "*" -notebook = "*" -qtconsole = "*" - -[[package]] -name = "jupyter-client" -version = "8.6.1" -description = "Jupyter protocol implementation and client libraries" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_client-8.6.1-py3-none-any.whl", hash = "sha256:3b7bd22f058434e3b9a7ea4b1500ed47de2713872288c0d511d19926f99b459f"}, - {file = "jupyter_client-8.6.1.tar.gz", hash = "sha256:e842515e2bab8e19186d89fdfea7abd15e39dd581f94e399f00e2af5a1652d3f"}, -] - -[package.dependencies] -jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" -python-dateutil = ">=2.8.2" -pyzmq = ">=23.0" -tornado = ">=6.2" -traitlets = ">=5.3" - -[package.extras] -docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] - -[[package]] -name = "jupyter-console" -version = "6.6.3" -description = "Jupyter terminal console" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485"}, - {file = "jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539"}, -] - -[package.dependencies] -ipykernel = ">=6.14" -ipython = "*" -jupyter-client = ">=7.0.0" -jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" -prompt-toolkit = ">=3.0.30" -pygments = "*" -pyzmq = ">=17" -traitlets = ">=5.4" - -[package.extras] -test = ["flaky", "pexpect", "pytest"] - -[[package]] -name = "jupyter-core" -version = "5.7.2" -description = "Jupyter core package. A base package on which Jupyter projects rely." -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, - {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, -] - -[package.dependencies] -platformdirs = ">=2.5" -pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} -traitlets = ">=5.3" - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] -test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] - -[[package]] -name = "jupyter-events" -version = "0.10.0" -description = "Jupyter Event System library" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, - {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, -] - -[package.dependencies] -jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]} -python-json-logger = ">=2.0.4" -pyyaml = ">=5.3" -referencing = "*" -rfc3339-validator = "*" -rfc3986-validator = ">=0.1.1" -traitlets = ">=5.3" - -[package.extras] -cli = ["click", "rich"] -docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] -test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"] - -[[package]] -name = "jupyter-lsp" -version = "2.2.5" -description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, - {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, -] - -[package.dependencies] -jupyter-server = ">=1.1.2" - -[[package]] -name = "jupyter-server" -version = "2.14.0" -description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_server-2.14.0-py3-none-any.whl", hash = "sha256:fb6be52c713e80e004fac34b35a0990d6d36ba06fd0a2b2ed82b899143a64210"}, - {file = "jupyter_server-2.14.0.tar.gz", hash = "sha256:659154cea512083434fd7c93b7fe0897af7a2fd0b9dd4749282b42eaac4ae677"}, -] - -[package.dependencies] -anyio = ">=3.1.0" -argon2-cffi = ">=21.1" -jinja2 = ">=3.0.3" -jupyter-client = ">=7.4.4" -jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" -jupyter-events = ">=0.9.0" -jupyter-server-terminals = ">=0.4.4" -nbconvert = ">=6.4.4" -nbformat = ">=5.3.0" -overrides = ">=5.0" -packaging = ">=22.0" -prometheus-client = ">=0.9" -pywinpty = {version = ">=2.0.1", markers = "os_name == \"nt\""} -pyzmq = ">=24" -send2trash = ">=1.8.2" -terminado = ">=0.8.3" -tornado = ">=6.2.0" -traitlets = ">=5.6.0" -websocket-client = ">=1.7" - -[package.extras] -docs = ["ipykernel", "jinja2", "jupyter-client", "jupyter-server", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] -test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0,<9)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.7)", "pytest-timeout", "requests"] - -[[package]] -name = "jupyter-server-terminals" -version = "0.5.3" -description = "A Jupyter Server Extension Providing Terminals." -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, - {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, -] - -[package.dependencies] -pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} -terminado = ">=0.8.3" - -[package.extras] -docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] -test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] - -[[package]] -name = "jupyterlab" -version = "4.1.6" -description = "JupyterLab computational environment" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyterlab-4.1.6-py3-none-any.whl", hash = "sha256:cf3e862bc10dbf4331e4eb37438634f813c238cfc62c71c640b3b3b2caa089a8"}, - {file = "jupyterlab-4.1.6.tar.gz", hash = "sha256:7935f36ba26eb615183a4f5c2bbca5791b5108ce2a00b5505f8cfd100d53648e"}, -] - -[package.dependencies] -async-lru = ">=1.0.0" -httpx = ">=0.25.0" -ipykernel = ">=6.5.0" -jinja2 = ">=3.0.3" -jupyter-core = "*" -jupyter-lsp = ">=2.0.0" -jupyter-server = ">=2.4.0,<3" -jupyterlab-server = ">=2.19.0,<3" -notebook-shim = ">=0.2" -packaging = "*" -tomli = {version = ">=1.2.2", markers = "python_version < \"3.11\""} -tornado = ">=6.2.0" -traitlets = "*" - -[package.extras] -dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.2.0)"] -docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<7.3.0)", "sphinx-copybutton"] -docs-screenshots = ["altair (==5.2.0)", "ipython (==8.16.1)", "ipywidgets (==8.1.1)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.0.post6)", "matplotlib (==3.8.2)", "nbconvert (>=7.0.0)", "pandas (==2.2.0)", "scipy (==1.12.0)", "vega-datasets (==0.9.0)"] -test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"] -upgrade-extension = ["copier (>=8.0,<9.0)", "jinja2-time (<0.3)", "pydantic (<2.0)", "pyyaml-include (<2.0)", "tomli-w (<2.0)"] - -[[package]] -name = "jupyterlab-pygments" -version = "0.3.0" -description = "Pygments theme using JupyterLab CSS variables" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, - {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, -] - -[[package]] -name = "jupyterlab-server" -version = "2.27.1" -description = "A set of server components for JupyterLab and JupyterLab like applications." -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyterlab_server-2.27.1-py3-none-any.whl", hash = "sha256:f5e26156e5258b24d532c84e7c74cc212e203bff93eb856f81c24c16daeecc75"}, - {file = "jupyterlab_server-2.27.1.tar.gz", hash = "sha256:097b5ac709b676c7284ac9c5e373f11930a561f52cd5a86e4fc7e5a9c8a8631d"}, -] - -[package.dependencies] -babel = ">=2.10" -jinja2 = ">=3.0.3" -json5 = ">=0.9.0" -jsonschema = ">=4.18.0" -jupyter-server = ">=1.21,<3" -packaging = ">=21.3" -requests = ">=2.31" - -[package.extras] -docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] -openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] -test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0,<8)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] - -[[package]] -name = "jupyterlab-widgets" -version = "3.0.10" -description = "Jupyter interactive widgets for JupyterLab" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jupyterlab_widgets-3.0.10-py3-none-any.whl", hash = "sha256:dd61f3ae7a5a7f80299e14585ce6cf3d6925a96c9103c978eda293197730cb64"}, - {file = "jupyterlab_widgets-3.0.10.tar.gz", hash = "sha256:04f2ac04976727e4f9d0fa91cdc2f1ab860f965e504c29dbd6a65c882c9d04c0"}, -] - -[[package]] -name = "kiwisolver" -version = "1.4.5" -description = "A fast implementation of the Cassowary constraint solver" +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" optional = false python-versions = ">=3.7" files = [ @@ -1322,75 +369,6 @@ files = [ {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, ] -[[package]] -name = "markupsafe" -version = "2.1.5" -description = "Safely add untrusted strings to HTML/XML markup." -optional = false -python-versions = ">=3.7" -files = [ - {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, - {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, -] - [[package]] name = "matplotlib" version = "3.8.4" @@ -1439,162 +417,6 @@ pillow = ">=8" pyparsing = ">=2.3.1" python-dateutil = ">=2.7" -[[package]] -name = "matplotlib-inline" -version = "0.1.7" -description = "Inline Matplotlib backend for Jupyter" -optional = false -python-versions = ">=3.8" -files = [ - {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, - {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, -] - -[package.dependencies] -traitlets = "*" - -[[package]] -name = "mistune" -version = "3.0.2" -description = "A sane and fast Markdown parser with useful plugins and renderers" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, - {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, -] - -[[package]] -name = "nbclient" -version = "0.10.0" -description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." -optional = false -python-versions = ">=3.8.0" -files = [ - {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, - {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, -] - -[package.dependencies] -jupyter-client = ">=6.1.12" -jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" -nbformat = ">=5.1" -traitlets = ">=5.4" - -[package.extras] -dev = ["pre-commit"] -docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] -test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] - -[[package]] -name = "nbconvert" -version = "7.16.3" -description = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." -optional = false -python-versions = ">=3.8" -files = [ - {file = "nbconvert-7.16.3-py3-none-any.whl", hash = "sha256:ddeff14beeeedf3dd0bc506623e41e4507e551736de59df69a91f86700292b3b"}, - {file = "nbconvert-7.16.3.tar.gz", hash = "sha256:a6733b78ce3d47c3f85e504998495b07e6ea9cf9bf6ec1c98dda63ec6ad19142"}, -] - -[package.dependencies] -beautifulsoup4 = "*" -bleach = "!=5.0.0" -defusedxml = "*" -jinja2 = ">=3.0" -jupyter-core = ">=4.7" -jupyterlab-pygments = "*" -markupsafe = ">=2.0" -mistune = ">=2.0.3,<4" -nbclient = ">=0.5.0" -nbformat = ">=5.7" -packaging = "*" -pandocfilters = ">=1.4.1" -pygments = ">=2.4.1" -tinycss2 = "*" -traitlets = ">=5.1" - -[package.extras] -all = ["nbconvert[docs,qtpdf,serve,test,webpdf]"] -docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] -qtpdf = ["nbconvert[qtpng]"] -qtpng = ["pyqtwebengine (>=5.15)"] -serve = ["tornado (>=6.1)"] -test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest (>=7)"] -webpdf = ["playwright"] - -[[package]] -name = "nbformat" -version = "5.10.4" -description = "The Jupyter Notebook format" -optional = false -python-versions = ">=3.8" -files = [ - {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, - {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, -] - -[package.dependencies] -fastjsonschema = ">=2.15" -jsonschema = ">=2.6" -jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" -traitlets = ">=5.1" - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["pep440", "pre-commit", "pytest", "testpath"] - -[[package]] -name = "nest-asyncio" -version = "1.6.0" -description = "Patch asyncio to allow nested event loops" -optional = false -python-versions = ">=3.5" -files = [ - {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, - {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, -] - -[[package]] -name = "notebook" -version = "7.1.3" -description = "Jupyter Notebook - A web-based notebook environment for interactive computing" -optional = false -python-versions = ">=3.8" -files = [ - {file = "notebook-7.1.3-py3-none-any.whl", hash = "sha256:919b911e59f41f6e3857ce93c9d93535ba66bb090059712770e5968c07e1004d"}, - {file = "notebook-7.1.3.tar.gz", hash = "sha256:41fcebff44cf7bb9377180808bcbae066629b55d8c7722f1ebbe75ca44f9cfc1"}, -] - -[package.dependencies] -jupyter-server = ">=2.4.0,<3" -jupyterlab = ">=4.1.1,<4.2" -jupyterlab-server = ">=2.22.1,<3" -notebook-shim = ">=0.2,<0.3" -tornado = ">=6.2.0" - -[package.extras] -dev = ["hatch", "pre-commit"] -docs = ["myst-parser", "nbsphinx", "pydata-sphinx-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] - -[[package]] -name = "notebook-shim" -version = "0.2.4" -description = "A shim layer for notebook traits and config" -optional = false -python-versions = ">=3.7" -files = [ - {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, - {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, -] - -[package.dependencies] -jupyter-server = ">=1.8,<3" - -[package.extras] -test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"] - [[package]] name = "numpy" version = "1.26.4" @@ -1640,17 +462,6 @@ files = [ {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, ] -[[package]] -name = "overrides" -version = "7.7.0" -description = "A decorator to automatically detect mismatch when overriding a method." -optional = false -python-versions = ">=3.6" -files = [ - {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, - {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, -] - [[package]] name = "packaging" version = "24.0" @@ -1662,46 +473,6 @@ files = [ {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, ] -[[package]] -name = "pandocfilters" -version = "1.5.1" -description = "Utilities for writing pandoc filters in python" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -files = [ - {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, - {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, -] - -[[package]] -name = "parso" -version = "0.8.4" -description = "A Python Parser" -optional = false -python-versions = ">=3.6" -files = [ - {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, - {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, -] - -[package.extras] -qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] -testing = ["docopt", "pytest"] - -[[package]] -name = "pexpect" -version = "4.9.0" -description = "Pexpect allows easy control of interactive console applications." -optional = false -python-versions = "*" -files = [ - {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, - {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, -] - -[package.dependencies] -ptyprocess = ">=0.5" - [[package]] name = "pillow" version = "10.3.0" @@ -1788,127 +559,20 @@ tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "pa typing = ["typing-extensions"] xmp = ["defusedxml"] -[[package]] -name = "platformdirs" -version = "4.2.0" -description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." -optional = false -python-versions = ">=3.8" -files = [ - {file = "platformdirs-4.2.0-py3-none-any.whl", hash = "sha256:0614df2a2f37e1a662acbd8e2b25b92ccf8632929bc6d43467e17fe89c75e068"}, - {file = "platformdirs-4.2.0.tar.gz", hash = "sha256:ef0cc731df711022c174543cb70a9b5bd22e5a9337c8624ef2c2ceb8ddad8768"}, -] - -[package.extras] -docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] -test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] - -[[package]] -name = "prometheus-client" -version = "0.20.0" -description = "Python client for the Prometheus monitoring system." -optional = false -python-versions = ">=3.8" -files = [ - {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, - {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, -] - -[package.extras] -twisted = ["twisted"] - -[[package]] -name = "prompt-toolkit" -version = "3.0.43" -description = "Library for building powerful interactive command lines in Python" -optional = false -python-versions = ">=3.7.0" -files = [ - {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, - {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, -] - -[package.dependencies] -wcwidth = "*" - -[[package]] -name = "psutil" -version = "5.9.8" -description = "Cross-platform lib for process and system monitoring in Python." -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" -files = [ - {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, - {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, - {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, - {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, - {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, - {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, - {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, - {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, - {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, - {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, - {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, - {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, - {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, - {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, - {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, - {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, -] - -[package.extras] -test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] - -[[package]] -name = "ptyprocess" -version = "0.7.0" -description = "Run a subprocess in a pseudo terminal" -optional = false -python-versions = "*" -files = [ - {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, - {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, -] - -[[package]] -name = "pure-eval" -version = "0.2.2" -description = "Safely evaluate AST nodes without side effects" -optional = false -python-versions = "*" -files = [ - {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, - {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, -] - -[package.extras] -tests = ["pytest"] - -[[package]] -name = "pycparser" -version = "2.22" -description = "C parser in Python" -optional = false -python-versions = ">=3.8" -files = [ - {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, - {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, -] - [[package]] name = "pydantic" -version = "2.7.0" +version = "2.7.1" description = "Data validation using Python type hints" optional = false python-versions = ">=3.8" files = [ - {file = "pydantic-2.7.0-py3-none-any.whl", hash = "sha256:9dee74a271705f14f9a1567671d144a851c675b072736f0a7b2608fd9e495352"}, - {file = "pydantic-2.7.0.tar.gz", hash = "sha256:b5ecdd42262ca2462e2624793551e80911a1e989f462910bb81aef974b4bb383"}, + {file = "pydantic-2.7.1-py3-none-any.whl", hash = "sha256:e029badca45266732a9a79898a15ae2e8b14840b1eabbb25844be28f0b33f3d5"}, + {file = "pydantic-2.7.1.tar.gz", hash = "sha256:e9dbb5eada8abe4d9ae5f46b9939aead650cd2b68f249bb3a8139dbe125803cc"}, ] [package.dependencies] annotated-types = ">=0.4.0" -pydantic-core = "2.18.1" +pydantic-core = "2.18.2" typing-extensions = ">=4.6.1" [package.extras] @@ -1916,110 +580,95 @@ email = ["email-validator (>=2.0.0)"] [[package]] name = "pydantic-core" -version = "2.18.1" +version = "2.18.2" description = "Core functionality for Pydantic validation and serialization" optional = false python-versions = ">=3.8" files = [ - {file = "pydantic_core-2.18.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ee9cf33e7fe14243f5ca6977658eb7d1042caaa66847daacbd2117adb258b226"}, - {file = "pydantic_core-2.18.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6b7bbb97d82659ac8b37450c60ff2e9f97e4eb0f8a8a3645a5568b9334b08b50"}, - {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df4249b579e75094f7e9bb4bd28231acf55e308bf686b952f43100a5a0be394c"}, - {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d0491006a6ad20507aec2be72e7831a42efc93193d2402018007ff827dc62926"}, - {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ae80f72bb7a3e397ab37b53a2b49c62cc5496412e71bc4f1277620a7ce3f52b"}, - {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:58aca931bef83217fca7a390e0486ae327c4af9c3e941adb75f8772f8eeb03a1"}, - {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1be91ad664fc9245404a789d60cba1e91c26b1454ba136d2a1bf0c2ac0c0505a"}, - {file = "pydantic_core-2.18.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:667880321e916a8920ef49f5d50e7983792cf59f3b6079f3c9dac2b88a311d17"}, - {file = "pydantic_core-2.18.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f7054fdc556f5421f01e39cbb767d5ec5c1139ea98c3e5b350e02e62201740c7"}, - {file = "pydantic_core-2.18.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:030e4f9516f9947f38179249778709a460a3adb516bf39b5eb9066fcfe43d0e6"}, - {file = "pydantic_core-2.18.1-cp310-none-win32.whl", hash = "sha256:2e91711e36e229978d92642bfc3546333a9127ecebb3f2761372e096395fc649"}, - {file = "pydantic_core-2.18.1-cp310-none-win_amd64.whl", hash = "sha256:9a29726f91c6cb390b3c2338f0df5cd3e216ad7a938762d11c994bb37552edb0"}, - {file = "pydantic_core-2.18.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9ece8a49696669d483d206b4474c367852c44815fca23ac4e48b72b339807f80"}, - {file = "pydantic_core-2.18.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a5d83efc109ceddb99abd2c1316298ced2adb4570410defe766851a804fcd5b"}, - {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f7973c381283783cd1043a8c8f61ea5ce7a3a58b0369f0ee0ee975eaf2f2a1b"}, - {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:54c7375c62190a7845091f521add19b0f026bcf6ae674bdb89f296972272e86d"}, - {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd63cec4e26e790b70544ae5cc48d11b515b09e05fdd5eff12e3195f54b8a586"}, - {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:561cf62c8a3498406495cfc49eee086ed2bb186d08bcc65812b75fda42c38294"}, - {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68717c38a68e37af87c4da20e08f3e27d7e4212e99e96c3d875fbf3f4812abfc"}, - {file = "pydantic_core-2.18.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2d5728e93d28a3c63ee513d9ffbac9c5989de8c76e049dbcb5bfe4b923a9739d"}, - {file = "pydantic_core-2.18.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f0f17814c505f07806e22b28856c59ac80cee7dd0fbb152aed273e116378f519"}, - {file = "pydantic_core-2.18.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d816f44a51ba5175394bc6c7879ca0bd2be560b2c9e9f3411ef3a4cbe644c2e9"}, - {file = "pydantic_core-2.18.1-cp311-none-win32.whl", hash = "sha256:09f03dfc0ef8c22622eaa8608caa4a1e189cfb83ce847045eca34f690895eccb"}, - {file = "pydantic_core-2.18.1-cp311-none-win_amd64.whl", hash = "sha256:27f1009dc292f3b7ca77feb3571c537276b9aad5dd4efb471ac88a8bd09024e9"}, - {file = "pydantic_core-2.18.1-cp311-none-win_arm64.whl", hash = "sha256:48dd883db92e92519201f2b01cafa881e5f7125666141a49ffba8b9facc072b0"}, - {file = "pydantic_core-2.18.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b6b0e4912030c6f28bcb72b9ebe4989d6dc2eebcd2a9cdc35fefc38052dd4fe8"}, - {file = "pydantic_core-2.18.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3202a429fe825b699c57892d4371c74cc3456d8d71b7f35d6028c96dfecad31"}, - {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3982b0a32d0a88b3907e4b0dc36809fda477f0757c59a505d4e9b455f384b8b"}, - {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25595ac311f20e5324d1941909b0d12933f1fd2171075fcff763e90f43e92a0d"}, - {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:14fe73881cf8e4cbdaded8ca0aa671635b597e42447fec7060d0868b52d074e6"}, - {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ca976884ce34070799e4dfc6fbd68cb1d181db1eefe4a3a94798ddfb34b8867f"}, - {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:684d840d2c9ec5de9cb397fcb3f36d5ebb6fa0d94734f9886032dd796c1ead06"}, - {file = "pydantic_core-2.18.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:54764c083bbe0264f0f746cefcded6cb08fbbaaf1ad1d78fb8a4c30cff999a90"}, - {file = "pydantic_core-2.18.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:201713f2f462e5c015b343e86e68bd8a530a4f76609b33d8f0ec65d2b921712a"}, - {file = "pydantic_core-2.18.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fd1a9edb9dd9d79fbeac1ea1f9a8dd527a6113b18d2e9bcc0d541d308dae639b"}, - {file = "pydantic_core-2.18.1-cp312-none-win32.whl", hash = "sha256:d5e6b7155b8197b329dc787356cfd2684c9d6a6b1a197f6bbf45f5555a98d411"}, - {file = "pydantic_core-2.18.1-cp312-none-win_amd64.whl", hash = "sha256:9376d83d686ec62e8b19c0ac3bf8d28d8a5981d0df290196fb6ef24d8a26f0d6"}, - {file = "pydantic_core-2.18.1-cp312-none-win_arm64.whl", hash = "sha256:c562b49c96906b4029b5685075fe1ebd3b5cc2601dfa0b9e16c2c09d6cbce048"}, - {file = "pydantic_core-2.18.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:3e352f0191d99fe617371096845070dee295444979efb8f27ad941227de6ad09"}, - {file = "pydantic_core-2.18.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c0295d52b012cbe0d3059b1dba99159c3be55e632aae1999ab74ae2bd86a33d7"}, - {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56823a92075780582d1ffd4489a2e61d56fd3ebb4b40b713d63f96dd92d28144"}, - {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dd3f79e17b56741b5177bcc36307750d50ea0698df6aa82f69c7db32d968c1c2"}, - {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38a5024de321d672a132b1834a66eeb7931959c59964b777e8f32dbe9523f6b1"}, - {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d2ce426ee691319d4767748c8e0895cfc56593d725594e415f274059bcf3cb76"}, - {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2adaeea59849ec0939af5c5d476935f2bab4b7f0335b0110f0f069a41024278e"}, - {file = "pydantic_core-2.18.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9b6431559676a1079eac0f52d6d0721fb8e3c5ba43c37bc537c8c83724031feb"}, - {file = "pydantic_core-2.18.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:85233abb44bc18d16e72dc05bf13848a36f363f83757541f1a97db2f8d58cfd9"}, - {file = "pydantic_core-2.18.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:641a018af4fe48be57a2b3d7a1f0f5dbca07c1d00951d3d7463f0ac9dac66622"}, - {file = "pydantic_core-2.18.1-cp38-none-win32.whl", hash = "sha256:63d7523cd95d2fde0d28dc42968ac731b5bb1e516cc56b93a50ab293f4daeaad"}, - {file = "pydantic_core-2.18.1-cp38-none-win_amd64.whl", hash = "sha256:907a4d7720abfcb1c81619863efd47c8a85d26a257a2dbebdb87c3b847df0278"}, - {file = "pydantic_core-2.18.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:aad17e462f42ddbef5984d70c40bfc4146c322a2da79715932cd8976317054de"}, - {file = "pydantic_core-2.18.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:94b9769ba435b598b547c762184bcfc4783d0d4c7771b04a3b45775c3589ca44"}, - {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:80e0e57cc704a52fb1b48f16d5b2c8818da087dbee6f98d9bf19546930dc64b5"}, - {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:76b86e24039c35280ceee6dce7e62945eb93a5175d43689ba98360ab31eebc4a"}, - {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12a05db5013ec0ca4a32cc6433f53faa2a014ec364031408540ba858c2172bb0"}, - {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:250ae39445cb5475e483a36b1061af1bc233de3e9ad0f4f76a71b66231b07f88"}, - {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a32204489259786a923e02990249c65b0f17235073149d0033efcebe80095570"}, - {file = "pydantic_core-2.18.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6395a4435fa26519fd96fdccb77e9d00ddae9dd6c742309bd0b5610609ad7fb2"}, - {file = "pydantic_core-2.18.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2533ad2883f001efa72f3d0e733fb846710c3af6dcdd544fe5bf14fa5fe2d7db"}, - {file = "pydantic_core-2.18.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b560b72ed4816aee52783c66854d96157fd8175631f01ef58e894cc57c84f0f6"}, - {file = "pydantic_core-2.18.1-cp39-none-win32.whl", hash = "sha256:582cf2cead97c9e382a7f4d3b744cf0ef1a6e815e44d3aa81af3ad98762f5a9b"}, - {file = "pydantic_core-2.18.1-cp39-none-win_amd64.whl", hash = "sha256:ca71d501629d1fa50ea7fa3b08ba884fe10cefc559f5c6c8dfe9036c16e8ae89"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e178e5b66a06ec5bf51668ec0d4ac8cfb2bdcb553b2c207d58148340efd00143"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:72722ce529a76a4637a60be18bd789d8fb871e84472490ed7ddff62d5fed620d"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fe0c1ce5b129455e43f941f7a46f61f3d3861e571f2905d55cdbb8b5c6f5e2c"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4284c621f06a72ce2cb55f74ea3150113d926a6eb78ab38340c08f770eb9b4d"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a0c3e718f4e064efde68092d9d974e39572c14e56726ecfaeebbe6544521f47"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:2027493cc44c23b598cfaf200936110433d9caa84e2c6cf487a83999638a96ac"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:76909849d1a6bffa5a07742294f3fa1d357dc917cb1fe7b470afbc3a7579d539"}, - {file = "pydantic_core-2.18.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ee7ccc7fb7e921d767f853b47814c3048c7de536663e82fbc37f5eb0d532224b"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ee2794111c188548a4547eccc73a6a8527fe2af6cf25e1a4ebda2fd01cdd2e60"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a139fe9f298dc097349fb4f28c8b81cc7a202dbfba66af0e14be5cfca4ef7ce5"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d074b07a10c391fc5bbdcb37b2f16f20fcd9e51e10d01652ab298c0d07908ee2"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c69567ddbac186e8c0aadc1f324a60a564cfe25e43ef2ce81bcc4b8c3abffbae"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:baf1c7b78cddb5af00971ad5294a4583188bda1495b13760d9f03c9483bb6203"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:2684a94fdfd1b146ff10689c6e4e815f6a01141781c493b97342cdc5b06f4d5d"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:73c1bc8a86a5c9e8721a088df234265317692d0b5cd9e86e975ce3bc3db62a59"}, - {file = "pydantic_core-2.18.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e60defc3c15defb70bb38dd605ff7e0fae5f6c9c7cbfe0ad7868582cb7e844a6"}, - {file = "pydantic_core-2.18.1.tar.gz", hash = "sha256:de9d3e8717560eb05e28739d1b35e4eac2e458553a52a301e51352a7ffc86a35"}, + {file = "pydantic_core-2.18.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:9e08e867b306f525802df7cd16c44ff5ebbe747ff0ca6cf3fde7f36c05a59a81"}, + {file = "pydantic_core-2.18.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f0a21cbaa69900cbe1a2e7cad2aa74ac3cf21b10c3efb0fa0b80305274c0e8a2"}, + {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0680b1f1f11fda801397de52c36ce38ef1c1dc841a0927a94f226dea29c3ae3d"}, + {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:95b9d5e72481d3780ba3442eac863eae92ae43a5f3adb5b4d0a1de89d42bb250"}, + {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fcf5cd9c4b655ad666ca332b9a081112cd7a58a8b5a6ca7a3104bc950f2038"}, + {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b5155ff768083cb1d62f3e143b49a8a3432e6789a3abee8acd005c3c7af1c74"}, + {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:553ef617b6836fc7e4df130bb851e32fe357ce36336d897fd6646d6058d980af"}, + {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b89ed9eb7d616ef5714e5590e6cf7f23b02d0d539767d33561e3675d6f9e3857"}, + {file = "pydantic_core-2.18.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:75f7e9488238e920ab6204399ded280dc4c307d034f3924cd7f90a38b1829563"}, + {file = "pydantic_core-2.18.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ef26c9e94a8c04a1b2924149a9cb081836913818e55681722d7f29af88fe7b38"}, + {file = "pydantic_core-2.18.2-cp310-none-win32.whl", hash = "sha256:182245ff6b0039e82b6bb585ed55a64d7c81c560715d1bad0cbad6dfa07b4027"}, + {file = "pydantic_core-2.18.2-cp310-none-win_amd64.whl", hash = "sha256:e23ec367a948b6d812301afc1b13f8094ab7b2c280af66ef450efc357d2ae543"}, + {file = "pydantic_core-2.18.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:219da3f096d50a157f33645a1cf31c0ad1fe829a92181dd1311022f986e5fbe3"}, + {file = "pydantic_core-2.18.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cc1cfd88a64e012b74e94cd00bbe0f9c6df57049c97f02bb07d39e9c852e19a4"}, + {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05b7133a6e6aeb8df37d6f413f7705a37ab4031597f64ab56384c94d98fa0e90"}, + {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:224c421235f6102e8737032483f43c1a8cfb1d2f45740c44166219599358c2cd"}, + {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b14d82cdb934e99dda6d9d60dc84a24379820176cc4a0d123f88df319ae9c150"}, + {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2728b01246a3bba6de144f9e3115b532ee44bd6cf39795194fb75491824a1413"}, + {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:470b94480bb5ee929f5acba6995251ada5e059a5ef3e0dfc63cca287283ebfa6"}, + {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:997abc4df705d1295a42f95b4eec4950a37ad8ae46d913caeee117b6b198811c"}, + {file = "pydantic_core-2.18.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:75250dbc5290e3f1a0f4618db35e51a165186f9034eff158f3d490b3fed9f8a0"}, + {file = "pydantic_core-2.18.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4456f2dca97c425231d7315737d45239b2b51a50dc2b6f0c2bb181fce6207664"}, + {file = "pydantic_core-2.18.2-cp311-none-win32.whl", hash = "sha256:269322dcc3d8bdb69f054681edff86276b2ff972447863cf34c8b860f5188e2e"}, + {file = "pydantic_core-2.18.2-cp311-none-win_amd64.whl", hash = "sha256:800d60565aec896f25bc3cfa56d2277d52d5182af08162f7954f938c06dc4ee3"}, + {file = "pydantic_core-2.18.2-cp311-none-win_arm64.whl", hash = "sha256:1404c69d6a676245199767ba4f633cce5f4ad4181f9d0ccb0577e1f66cf4c46d"}, + {file = "pydantic_core-2.18.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:fb2bd7be70c0fe4dfd32c951bc813d9fe6ebcbfdd15a07527796c8204bd36242"}, + {file = "pydantic_core-2.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6132dd3bd52838acddca05a72aafb6eab6536aa145e923bb50f45e78b7251043"}, + {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7d904828195733c183d20a54230c0df0eb46ec746ea1a666730787353e87182"}, + {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c9bd70772c720142be1020eac55f8143a34ec9f82d75a8e7a07852023e46617f"}, + {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2b8ed04b3582771764538f7ee7001b02e1170223cf9b75dff0bc698fadb00cf3"}, + {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e6dac87ddb34aaec85f873d737e9d06a3555a1cc1a8e0c44b7f8d5daeb89d86f"}, + {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ca4ae5a27ad7a4ee5170aebce1574b375de390bc01284f87b18d43a3984df72"}, + {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:886eec03591b7cf058467a70a87733b35f44707bd86cf64a615584fd72488b7c"}, + {file = "pydantic_core-2.18.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ca7b0c1f1c983e064caa85f3792dd2fe3526b3505378874afa84baf662e12241"}, + {file = "pydantic_core-2.18.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b4356d3538c3649337df4074e81b85f0616b79731fe22dd11b99499b2ebbdf3"}, + {file = "pydantic_core-2.18.2-cp312-none-win32.whl", hash = "sha256:8b172601454f2d7701121bbec3425dd71efcb787a027edf49724c9cefc14c038"}, + {file = "pydantic_core-2.18.2-cp312-none-win_amd64.whl", hash = "sha256:b1bd7e47b1558ea872bd16c8502c414f9e90dcf12f1395129d7bb42a09a95438"}, + {file = "pydantic_core-2.18.2-cp312-none-win_arm64.whl", hash = "sha256:98758d627ff397e752bc339272c14c98199c613f922d4a384ddc07526c86a2ec"}, + {file = "pydantic_core-2.18.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:9fdad8e35f278b2c3eb77cbdc5c0a49dada440657bf738d6905ce106dc1de439"}, + {file = "pydantic_core-2.18.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1d90c3265ae107f91a4f279f4d6f6f1d4907ac76c6868b27dc7fb33688cfb347"}, + {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:390193c770399861d8df9670fb0d1874f330c79caaca4642332df7c682bf6b91"}, + {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:82d5d4d78e4448683cb467897fe24e2b74bb7b973a541ea1dcfec1d3cbce39fb"}, + {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4774f3184d2ef3e14e8693194f661dea5a4d6ca4e3dc8e39786d33a94865cefd"}, + {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4d938ec0adf5167cb335acb25a4ee69a8107e4984f8fbd2e897021d9e4ca21b"}, + {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0e8b1be28239fc64a88a8189d1df7fad8be8c1ae47fcc33e43d4be15f99cc70"}, + {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:868649da93e5a3d5eacc2b5b3b9235c98ccdbfd443832f31e075f54419e1b96b"}, + {file = "pydantic_core-2.18.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:78363590ef93d5d226ba21a90a03ea89a20738ee5b7da83d771d283fd8a56761"}, + {file = "pydantic_core-2.18.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:852e966fbd035a6468fc0a3496589b45e2208ec7ca95c26470a54daed82a0788"}, + {file = "pydantic_core-2.18.2-cp38-none-win32.whl", hash = "sha256:6a46e22a707e7ad4484ac9ee9f290f9d501df45954184e23fc29408dfad61350"}, + {file = "pydantic_core-2.18.2-cp38-none-win_amd64.whl", hash = "sha256:d91cb5ea8b11607cc757675051f61b3d93f15eca3cefb3e6c704a5d6e8440f4e"}, + {file = "pydantic_core-2.18.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:ae0a8a797a5e56c053610fa7be147993fe50960fa43609ff2a9552b0e07013e8"}, + {file = "pydantic_core-2.18.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:042473b6280246b1dbf530559246f6842b56119c2926d1e52b631bdc46075f2a"}, + {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a388a77e629b9ec814c1b1e6b3b595fe521d2cdc625fcca26fbc2d44c816804"}, + {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25add29b8f3b233ae90ccef2d902d0ae0432eb0d45370fe315d1a5cf231004b"}, + {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f459a5ce8434614dfd39bbebf1041952ae01da6bed9855008cb33b875cb024c0"}, + {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eff2de745698eb46eeb51193a9f41d67d834d50e424aef27df2fcdee1b153845"}, + {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8309f67285bdfe65c372ea3722b7a5642680f3dba538566340a9d36e920b5f0"}, + {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f93a8a2e3938ff656a7c1bc57193b1319960ac015b6e87d76c76bf14fe0244b4"}, + {file = "pydantic_core-2.18.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:22057013c8c1e272eb8d0eebc796701167d8377441ec894a8fed1af64a0bf399"}, + {file = "pydantic_core-2.18.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:cfeecd1ac6cc1fb2692c3d5110781c965aabd4ec5d32799773ca7b1456ac636b"}, + {file = "pydantic_core-2.18.2-cp39-none-win32.whl", hash = "sha256:0d69b4c2f6bb3e130dba60d34c0845ba31b69babdd3f78f7c0c8fae5021a253e"}, + {file = "pydantic_core-2.18.2-cp39-none-win_amd64.whl", hash = "sha256:d9319e499827271b09b4e411905b24a426b8fb69464dfa1696258f53a3334641"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a1874c6dd4113308bd0eb568418e6114b252afe44319ead2b4081e9b9521fe75"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:ccdd111c03bfd3666bd2472b674c6899550e09e9f298954cfc896ab92b5b0e6d"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e18609ceaa6eed63753037fc06ebb16041d17d28199ae5aba0052c51449650a9"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e5c584d357c4e2baf0ff7baf44f4994be121e16a2c88918a5817331fc7599d7"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43f0f463cf89ace478de71a318b1b4f05ebc456a9b9300d027b4b57c1a2064fb"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:e1b395e58b10b73b07b7cf740d728dd4ff9365ac46c18751bf8b3d8cca8f625a"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0098300eebb1c837271d3d1a2cd2911e7c11b396eac9661655ee524a7f10587b"}, + {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:36789b70d613fbac0a25bb07ab3d9dba4d2e38af609c020cf4d888d165ee0bf3"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3f9a801e7c8f1ef8718da265bba008fa121243dfe37c1cea17840b0944dfd72c"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:3a6515ebc6e69d85502b4951d89131ca4e036078ea35533bb76327f8424531ce"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20aca1e2298c56ececfd8ed159ae4dde2df0781988c97ef77d5c16ff4bd5b400"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:223ee893d77a310a0391dca6df00f70bbc2f36a71a895cecd9a0e762dc37b349"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2334ce8c673ee93a1d6a65bd90327588387ba073c17e61bf19b4fd97d688d63c"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:cbca948f2d14b09d20268cda7b0367723d79063f26c4ffc523af9042cad95592"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b3ef08e20ec49e02d5c6717a91bb5af9b20f1805583cb0adfe9ba2c6b505b5ae"}, + {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6fdc8627910eed0c01aed6a390a252fe3ea6d472ee70fdde56273f198938374"}, + {file = "pydantic_core-2.18.2.tar.gz", hash = "sha256:2e29d20810dfc3043ee13ac7d9e25105799817683348823f305ab3f349b9386e"}, ] [package.dependencies] typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" -[[package]] -name = "pygments" -version = "2.17.2" -description = "Pygments is a syntax highlighting package written in Python." -optional = false -python-versions = ">=3.7" -files = [ - {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, - {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, -] - -[package.extras] -plugins = ["importlib-metadata"] -windows-terminal = ["colorama (>=0.4.6)"] - [[package]] name = "pyparsing" version = "3.1.2" @@ -2048,442 +697,6 @@ files = [ [package.dependencies] six = ">=1.5" -[[package]] -name = "python-json-logger" -version = "2.0.7" -description = "A python library adding a json log formatter" -optional = false -python-versions = ">=3.6" -files = [ - {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, - {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, -] - -[[package]] -name = "pywin32" -version = "306" -description = "Python for Window Extensions" -optional = false -python-versions = "*" -files = [ - {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, - {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, - {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, - {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, - {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, - {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, - {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, - {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, - {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, - {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, - {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, - {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, - {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, - {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, -] - -[[package]] -name = "pywinpty" -version = "2.0.13" -description = "Pseudo terminal support for Windows from Python." -optional = false -python-versions = ">=3.8" -files = [ - {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"}, - {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"}, - {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"}, - {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"}, - {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"}, - {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, -] - -[[package]] -name = "pyyaml" -version = "6.0.1" -description = "YAML parser and emitter for Python" -optional = false -python-versions = ">=3.6" -files = [ - {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, - {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, - {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, - {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, - {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, - {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, - {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, - {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, - {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, - {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, - {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, - {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, - {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, - {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, - {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, - {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, - {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, - {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, - {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, - {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, - {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, - {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, - {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, - {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, - {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, - {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, - {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, - {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, - {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, - {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, - {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, - {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, - {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, - {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, - {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, - {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, - {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, - {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, - {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, - {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, - {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, - {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, - {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, - {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, - {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, - {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, - {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, - {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, - {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, - {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, - {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, -] - -[[package]] -name = "pyzmq" -version = "26.0.2" -description = "Python bindings for 0MQ" -optional = false -python-versions = ">=3.7" -files = [ - {file = "pyzmq-26.0.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:1a60a03b01e8c9c58932ec0cca15b1712d911c2800eb82d4281bc1ae5b6dad50"}, - {file = "pyzmq-26.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:949067079e14ea1973bd740255e0840118c163d4bce8837f539d749f145cf5c3"}, - {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37e7edfa6cf96d036a403775c96afa25058d1bb940a79786a9a2fc94a783abe3"}, - {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:903cc7a84a7d4326b43755c368780800e035aa3d711deae84a533fdffa8755b0"}, - {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6cb2e41af165e5f327d06fbdd79a42a4e930267fade4e9f92d17f3ccce03f3a7"}, - {file = "pyzmq-26.0.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:55353b8189adcfc4c125fc4ce59d477744118e9c0ec379dd0999c5fa120ac4f5"}, - {file = "pyzmq-26.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f961423ff6236a752ced80057a20e623044df95924ed1009f844cde8b3a595f9"}, - {file = "pyzmq-26.0.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ba77fe84fe4f5f3dc0ef681a6d366685c8ffe1c8439c1d7530997b05ac06a04b"}, - {file = "pyzmq-26.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:52589f0a745ef61b9c75c872cf91f8c1f7c0668eb3dd99d7abd639d8c0fb9ca7"}, - {file = "pyzmq-26.0.2-cp310-cp310-win32.whl", hash = "sha256:b7b6d2a46c7afe2ad03ec8faf9967090c8ceae85c4d8934d17d7cae6f9062b64"}, - {file = "pyzmq-26.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:86531e20de249d9204cc6d8b13d5a30537748c78820215161d8a3b9ea58ca111"}, - {file = "pyzmq-26.0.2-cp310-cp310-win_arm64.whl", hash = "sha256:f26a05029ecd2bd306b941ff8cb80f7620b7901421052bc429d238305b1cbf2f"}, - {file = "pyzmq-26.0.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:70770e296a9cb03d955540c99360aab861cbb3cba29516abbd106a15dbd91268"}, - {file = "pyzmq-26.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2740fd7161b39e178554ebf21aa5667a1c9ef0cd2cb74298fd4ef017dae7aec4"}, - {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5e3706c32dea077faa42b1c92d825b7f86c866f72532d342e0be5e64d14d858"}, - {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0fa1416876194927f7723d6b7171b95e1115602967fc6bfccbc0d2d51d8ebae1"}, - {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ef9a79a48794099c57dc2df00340b5d47c5caa1792f9ddb8c7a26b1280bd575"}, - {file = "pyzmq-26.0.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1c60fcdfa3229aeee4291c5d60faed3a813b18bdadb86299c4bf49e8e51e8605"}, - {file = "pyzmq-26.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e943c39c206b04df2eb5d71305761d7c3ca75fd49452115ea92db1b5b98dbdef"}, - {file = "pyzmq-26.0.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:8da0ed8a598693731c76659880a668f4748b59158f26ed283a93f7f04d47447e"}, - {file = "pyzmq-26.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7bf51970b11d67096bede97cdbad0f4333f7664f4708b9b2acb352bf4faa3140"}, - {file = "pyzmq-26.0.2-cp311-cp311-win32.whl", hash = "sha256:6f8e6bd5d066be605faa9fe5ec10aa1a46ad9f18fc8646f2b9aaefc8fb575742"}, - {file = "pyzmq-26.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:6d03da3a0ae691b361edcb39530075461202f699ce05adbb15055a0e1c9bcaa4"}, - {file = "pyzmq-26.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:f84e33321b68ff00b60e9dbd1a483e31ab6022c577c8de525b8e771bd274ce68"}, - {file = "pyzmq-26.0.2-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:44c33ebd1c62a01db7fbc24e18bdda569d6639217d13d5929e986a2b0f69070d"}, - {file = "pyzmq-26.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ac04f904b4fce4afea9cdccbb78e24d468cb610a839d5a698853e14e2a3f9ecf"}, - {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2133de5ba9adc5f481884ccb699eac9ce789708292945c05746880f95b241c0"}, - {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7753c67c570d7fc80c2dc59b90ca1196f1224e0e2e29a548980c95fe0fe27fc1"}, - {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d4e51632e6b12e65e8d9d7612446ecda2eda637a868afa7bce16270194650dd"}, - {file = "pyzmq-26.0.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d6c38806f6ecd0acf3104b8d7e76a206bcf56dadd6ce03720d2fa9d9157d5718"}, - {file = "pyzmq-26.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:48f496bbe14686b51cec15406323ae6942851e14022efd7fc0e2ecd092c5982c"}, - {file = "pyzmq-26.0.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e84a3161149c75bb7a7dc8646384186c34033e286a67fec1ad1bdedea165e7f4"}, - {file = "pyzmq-26.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:dabf796c67aa9f5a4fcc956d47f0d48b5c1ed288d628cf53aa1cf08e88654343"}, - {file = "pyzmq-26.0.2-cp312-cp312-win32.whl", hash = "sha256:3eee4c676af1b109f708d80ef0cf57ecb8aaa5900d1edaf90406aea7e0e20e37"}, - {file = "pyzmq-26.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:26721fec65846b3e4450dad050d67d31b017f97e67f7e0647b5f98aa47f828cf"}, - {file = "pyzmq-26.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:653955c6c233e90de128a1b8e882abc7216f41f44218056bd519969c8c413a15"}, - {file = "pyzmq-26.0.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:becd8d8fb068fbb5a52096efd83a2d8e54354383f691781f53a4c26aee944542"}, - {file = "pyzmq-26.0.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:7a15e5465e7083c12517209c9dd24722b25e9b63c49a563922922fc03554eb35"}, - {file = "pyzmq-26.0.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e8158ac8616941f874841f9fa0f6d2f1466178c2ff91ea08353fdc19de0d40c2"}, - {file = "pyzmq-26.0.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea2c6a53e28c7066ea7db86fcc0b71d78d01b818bb11d4a4341ec35059885295"}, - {file = "pyzmq-26.0.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:bdbc7dab0b0e9c62c97b732899c4242e3282ba803bad668e03650b59b165466e"}, - {file = "pyzmq-26.0.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:e74b6d5ef57bb65bf1b4a37453d8d86d88550dde3fb0f23b1f1a24e60c70af5b"}, - {file = "pyzmq-26.0.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ed4c6ee624ecbc77b18aeeb07bf0700d26571ab95b8f723f0d02e056b5bce438"}, - {file = "pyzmq-26.0.2-cp37-cp37m-win32.whl", hash = "sha256:8a98b3cb0484b83c19d8fb5524c8a469cd9f10e743f5904ac285d92678ee761f"}, - {file = "pyzmq-26.0.2-cp37-cp37m-win_amd64.whl", hash = "sha256:aa5f95d71b6eca9cec28aa0a2f8310ea53dea313b63db74932879ff860c1fb8d"}, - {file = "pyzmq-26.0.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:5ff56c76ce77b9805378a7a73032c17cbdb1a5b84faa1df03c5d3e306e5616df"}, - {file = "pyzmq-26.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bab697fc1574fee4b81da955678708567c43c813c84c91074e452bda5346c921"}, - {file = "pyzmq-26.0.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0c0fed8aa9ba0488ee1cbdaa304deea92d52fab43d373297002cfcc69c0a20c5"}, - {file = "pyzmq-26.0.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:606b922699fcec472ed814dda4dc3ff7c748254e0b26762a0ba21a726eb1c107"}, - {file = "pyzmq-26.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45f0fd82bad4d199fa993fbf0ac586a7ac5879addbe436a35a389df7e0eb4c91"}, - {file = "pyzmq-26.0.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:166c5e41045939a52c01e6f374e493d9a6a45dfe677360d3e7026e38c42e8906"}, - {file = "pyzmq-26.0.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:d566e859e8b8d5bca08467c093061774924b3d78a5ba290e82735b2569edc84b"}, - {file = "pyzmq-26.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:264ee0e72b72ca59279dc320deab5ae0fac0d97881aed1875ce4bde2e56ffde0"}, - {file = "pyzmq-26.0.2-cp38-cp38-win32.whl", hash = "sha256:3152bbd3a4744cbdd83dfb210ed701838b8b0c9065cef14671d6d91df12197d0"}, - {file = "pyzmq-26.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:bf77601d75ca692c179154b7e5943c286a4aaffec02c491afe05e60493ce95f2"}, - {file = "pyzmq-26.0.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:c770a7545b3deca2db185b59175e710a820dd4ed43619f4c02e90b0e227c6252"}, - {file = "pyzmq-26.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d47175f0a380bfd051726bc5c0054036ae4a5d8caf922c62c8a172ccd95c1a2a"}, - {file = "pyzmq-26.0.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9bce298c1ce077837e110367c321285dc4246b531cde1abfc27e4a5bbe2bed4d"}, - {file = "pyzmq-26.0.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c40b09b7e184d6e3e1be1c8af2cc320c0f9f610d8a5df3dd866e6e6e4e32b235"}, - {file = "pyzmq-26.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d420d856bf728713874cefb911398efe69e1577835851dd297a308a78c14c249"}, - {file = "pyzmq-26.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d792d3cab987058451e55c70c5926e93e2ceb68ca5a2334863bb903eb860c9cb"}, - {file = "pyzmq-26.0.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:83ec17729cf6d3464dab98a11e98294fcd50e6b17eaabd3d841515c23f6dbd3a"}, - {file = "pyzmq-26.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47c17d5ebfa88ae90f08960c97b49917098665b8cd8be31f2c24e177bcf37a0f"}, - {file = "pyzmq-26.0.2-cp39-cp39-win32.whl", hash = "sha256:d509685d1cd1d018705a811c5f9d5bc237790936ead6d06f6558b77e16cc7235"}, - {file = "pyzmq-26.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:c7cc8cc009e8f6989a6d86c96f87dae5f5fb07d6c96916cdc7719d546152c7db"}, - {file = "pyzmq-26.0.2-cp39-cp39-win_arm64.whl", hash = "sha256:3ada31cb879cd7532f4a85b501f4255c747d4813ab76b35c49ed510ce4865b45"}, - {file = "pyzmq-26.0.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0a6ceaddc830dd3ca86cb8451cf373d1f05215368e11834538c2902ed5205139"}, - {file = "pyzmq-26.0.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a967681463aa7a99eb9a62bb18229b653b45c10ff0947b31cc0837a83dfb86f"}, - {file = "pyzmq-26.0.2-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6472a73bc115bc40a2076609a90894775abe6faf19a78375675a2f889a613071"}, - {file = "pyzmq-26.0.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d6aea92bcccfe5e5524d3c70a6f16ffdae548390ddad26f4207d55c55a40593"}, - {file = "pyzmq-26.0.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e025f6351e49d48a5aa2f5a09293aa769b0ee7369c25bed551647234b7fa0c75"}, - {file = "pyzmq-26.0.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:40bd7ebe4dbb37d27f0c56e2a844f360239343a99be422085e13e97da13f73f9"}, - {file = "pyzmq-26.0.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1dd40d586ad6f53764104df6e01810fe1b4e88fd353774629a5e6fe253813f79"}, - {file = "pyzmq-26.0.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f2aca15e9ad8c8657b5b3d7ae3d1724dc8c1c1059c06b4b674c3aa36305f4930"}, - {file = "pyzmq-26.0.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:450ec234736732eb0ebeffdb95a352450d4592f12c3e087e2a9183386d22c8bf"}, - {file = "pyzmq-26.0.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:f43be2bebbd09360a2f23af83b243dc25ffe7b583ea8c722e6df03e03a55f02f"}, - {file = "pyzmq-26.0.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:867f55e54aff254940bcec5eec068e7c0ac1e6bf360ab91479394a8bf356b0e6"}, - {file = "pyzmq-26.0.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b4dbc033c5ad46f8c429bf238c25a889b8c1d86bfe23a74e1031a991cb3f0000"}, - {file = "pyzmq-26.0.2-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6e8dd2961462e337e21092ec2da0c69d814dcb1b6e892955a37444a425e9cfb8"}, - {file = "pyzmq-26.0.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35391e72df6c14a09b697c7b94384947c1dd326aca883ff98ff137acdf586c33"}, - {file = "pyzmq-26.0.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:1c3d3c92fa54eda94ab369ca5b8d35059987c326ba5e55326eb068862f64b1fc"}, - {file = "pyzmq-26.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e7aa61a9cc4f0523373e31fc9255bf4567185a099f85ca3598e64de484da3ab2"}, - {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee53a8191271f144cc20b12c19daa9f1546adc84a2f33839e3338039b55c373c"}, - {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac60a980f07fa988983f7bfe6404ef3f1e4303f5288a01713bc1266df6d18783"}, - {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88896b1b4817d7b2fe1ec7205c4bbe07bf5d92fb249bf2d226ddea8761996068"}, - {file = "pyzmq-26.0.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:18dfffe23751edee917764ffa133d5d3fef28dfd1cf3adebef8c90bc854c74c4"}, - {file = "pyzmq-26.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:6926dd14cfe6967d3322640b6d5c3c3039db71716a5e43cca6e3b474e73e0b36"}, - {file = "pyzmq-26.0.2.tar.gz", hash = "sha256:f0f9bb370449158359bb72a3e12c658327670c0ffe6fbcd1af083152b64f9df0"}, -] - -[package.dependencies] -cffi = {version = "*", markers = "implementation_name == \"pypy\""} - -[[package]] -name = "qtconsole" -version = "5.5.1" -description = "Jupyter Qt console" -optional = false -python-versions = ">= 3.8" -files = [ - {file = "qtconsole-5.5.1-py3-none-any.whl", hash = "sha256:8c75fa3e9b4ed884880ff7cea90a1b67451219279ec33deaee1d59e3df1a5d2b"}, - {file = "qtconsole-5.5.1.tar.gz", hash = "sha256:a0e806c6951db9490628e4df80caec9669b65149c7ba40f9bf033c025a5b56bc"}, -] - -[package.dependencies] -ipykernel = ">=4.1" -jupyter-client = ">=4.1" -jupyter-core = "*" -packaging = "*" -pygments = "*" -pyzmq = ">=17.1" -qtpy = ">=2.4.0" -traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2" - -[package.extras] -doc = ["Sphinx (>=1.3)"] -test = ["flaky", "pytest", "pytest-qt"] - -[[package]] -name = "qtpy" -version = "2.4.1" -description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." -optional = false -python-versions = ">=3.7" -files = [ - {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, - {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, -] - -[package.dependencies] -packaging = "*" - -[package.extras] -test = ["pytest (>=6,!=7.0.0,!=7.0.1)", "pytest-cov (>=3.0.0)", "pytest-qt"] - -[[package]] -name = "referencing" -version = "0.34.0" -description = "JSON Referencing + Python" -optional = false -python-versions = ">=3.8" -files = [ - {file = "referencing-0.34.0-py3-none-any.whl", hash = "sha256:d53ae300ceddd3169f1ffa9caf2cb7b769e92657e4fafb23d34b93679116dfd4"}, - {file = "referencing-0.34.0.tar.gz", hash = "sha256:5773bd84ef41799a5a8ca72dc34590c041eb01bf9aa02632b4a973fb0181a844"}, -] - -[package.dependencies] -attrs = ">=22.2.0" -rpds-py = ">=0.7.0" - -[[package]] -name = "requests" -version = "2.31.0" -description = "Python HTTP for Humans." -optional = false -python-versions = ">=3.7" -files = [ - {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, - {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, -] - -[package.dependencies] -certifi = ">=2017.4.17" -charset-normalizer = ">=2,<4" -idna = ">=2.5,<4" -urllib3 = ">=1.21.1,<3" - -[package.extras] -socks = ["PySocks (>=1.5.6,!=1.5.7)"] -use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] - -[[package]] -name = "rfc3339-validator" -version = "0.1.4" -description = "A pure python RFC3339 validator" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, - {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, -] - -[package.dependencies] -six = "*" - -[[package]] -name = "rfc3986-validator" -version = "0.1.1" -description = "Pure python rfc3986 validator" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, - {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, -] - -[[package]] -name = "rpds-py" -version = "0.18.0" -description = "Python bindings to Rust's persistent data structures (rpds)" -optional = false -python-versions = ">=3.8" -files = [ - {file = "rpds_py-0.18.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:5b4e7d8d6c9b2e8ee2d55c90b59c707ca59bc30058269b3db7b1f8df5763557e"}, - {file = "rpds_py-0.18.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c463ed05f9dfb9baebef68048aed8dcdc94411e4bf3d33a39ba97e271624f8f7"}, - {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01e36a39af54a30f28b73096dd39b6802eddd04c90dbe161c1b8dbe22353189f"}, - {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d62dec4976954a23d7f91f2f4530852b0c7608116c257833922a896101336c51"}, - {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd18772815d5f008fa03d2b9a681ae38d5ae9f0e599f7dda233c439fcaa00d40"}, - {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:923d39efa3cfb7279a0327e337a7958bff00cc447fd07a25cddb0a1cc9a6d2da"}, - {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39514da80f971362f9267c600b6d459bfbbc549cffc2cef8e47474fddc9b45b1"}, - {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a34d557a42aa28bd5c48a023c570219ba2593bcbbb8dc1b98d8cf5d529ab1434"}, - {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:93df1de2f7f7239dc9cc5a4a12408ee1598725036bd2dedadc14d94525192fc3"}, - {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:34b18ba135c687f4dac449aa5157d36e2cbb7c03cbea4ddbd88604e076aa836e"}, - {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c0b5dcf9193625afd8ecc92312d6ed78781c46ecbf39af9ad4681fc9f464af88"}, - {file = "rpds_py-0.18.0-cp310-none-win32.whl", hash = "sha256:c4325ff0442a12113a6379af66978c3fe562f846763287ef66bdc1d57925d337"}, - {file = "rpds_py-0.18.0-cp310-none-win_amd64.whl", hash = "sha256:7223a2a5fe0d217e60a60cdae28d6949140dde9c3bcc714063c5b463065e3d66"}, - {file = "rpds_py-0.18.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3a96e0c6a41dcdba3a0a581bbf6c44bb863f27c541547fb4b9711fd8cf0ffad4"}, - {file = "rpds_py-0.18.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30f43887bbae0d49113cbaab729a112251a940e9b274536613097ab8b4899cf6"}, - {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fcb25daa9219b4cf3a0ab24b0eb9a5cc8949ed4dc72acb8fa16b7e1681aa3c58"}, - {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d68c93e381010662ab873fea609bf6c0f428b6d0bb00f2c6939782e0818d37bf"}, - {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b34b7aa8b261c1dbf7720b5d6f01f38243e9b9daf7e6b8bc1fd4657000062f2c"}, - {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2e6d75ab12b0bbab7215e5d40f1e5b738aa539598db27ef83b2ec46747df90e1"}, - {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b8612cd233543a3781bc659c731b9d607de65890085098986dfd573fc2befe5"}, - {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aec493917dd45e3c69d00a8874e7cbed844efd935595ef78a0f25f14312e33c6"}, - {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:661d25cbffaf8cc42e971dd570d87cb29a665f49f4abe1f9e76be9a5182c4688"}, - {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1df3659d26f539ac74fb3b0c481cdf9d725386e3552c6fa2974f4d33d78e544b"}, - {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a1ce3ba137ed54f83e56fb983a5859a27d43a40188ba798993812fed73c70836"}, - {file = "rpds_py-0.18.0-cp311-none-win32.whl", hash = "sha256:69e64831e22a6b377772e7fb337533c365085b31619005802a79242fee620bc1"}, - {file = "rpds_py-0.18.0-cp311-none-win_amd64.whl", hash = "sha256:998e33ad22dc7ec7e030b3df701c43630b5bc0d8fbc2267653577e3fec279afa"}, - {file = "rpds_py-0.18.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:7f2facbd386dd60cbbf1a794181e6aa0bd429bd78bfdf775436020172e2a23f0"}, - {file = "rpds_py-0.18.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1d9a5be316c15ffb2b3c405c4ff14448c36b4435be062a7f578ccd8b01f0c4d8"}, - {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cd5bf1af8efe569654bbef5a3e0a56eca45f87cfcffab31dd8dde70da5982475"}, - {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5417558f6887e9b6b65b4527232553c139b57ec42c64570569b155262ac0754f"}, - {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:56a737287efecafc16f6d067c2ea0117abadcd078d58721f967952db329a3e5c"}, - {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8f03bccbd8586e9dd37219bce4d4e0d3ab492e6b3b533e973fa08a112cb2ffc9"}, - {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4457a94da0d5c53dc4b3e4de1158bdab077db23c53232f37a3cb7afdb053a4e3"}, - {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0ab39c1ba9023914297dd88ec3b3b3c3f33671baeb6acf82ad7ce883f6e8e157"}, - {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d54553c1136b50fd12cc17e5b11ad07374c316df307e4cfd6441bea5fb68496"}, - {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0af039631b6de0397ab2ba16eaf2872e9f8fca391b44d3d8cac317860a700a3f"}, - {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:84ffab12db93b5f6bad84c712c92060a2d321b35c3c9960b43d08d0f639d60d7"}, - {file = "rpds_py-0.18.0-cp312-none-win32.whl", hash = "sha256:685537e07897f173abcf67258bee3c05c374fa6fff89d4c7e42fb391b0605e98"}, - {file = "rpds_py-0.18.0-cp312-none-win_amd64.whl", hash = "sha256:e003b002ec72c8d5a3e3da2989c7d6065b47d9eaa70cd8808b5384fbb970f4ec"}, - {file = "rpds_py-0.18.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:08f9ad53c3f31dfb4baa00da22f1e862900f45908383c062c27628754af2e88e"}, - {file = "rpds_py-0.18.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c0013fe6b46aa496a6749c77e00a3eb07952832ad6166bd481c74bda0dcb6d58"}, - {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e32a92116d4f2a80b629778280103d2a510a5b3f6314ceccd6e38006b5e92dcb"}, - {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e541ec6f2ec456934fd279a3120f856cd0aedd209fc3852eca563f81738f6861"}, - {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bed88b9a458e354014d662d47e7a5baafd7ff81c780fd91584a10d6ec842cb73"}, - {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2644e47de560eb7bd55c20fc59f6daa04682655c58d08185a9b95c1970fa1e07"}, - {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e8916ae4c720529e18afa0b879473049e95949bf97042e938530e072fde061d"}, - {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:465a3eb5659338cf2a9243e50ad9b2296fa15061736d6e26240e713522b6235c"}, - {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ea7d4a99f3b38c37eac212dbd6ec42b7a5ec51e2c74b5d3223e43c811609e65f"}, - {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:67071a6171e92b6da534b8ae326505f7c18022c6f19072a81dcf40db2638767c"}, - {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:41ef53e7c58aa4ef281da975f62c258950f54b76ec8e45941e93a3d1d8580594"}, - {file = "rpds_py-0.18.0-cp38-none-win32.whl", hash = "sha256:fdea4952db2793c4ad0bdccd27c1d8fdd1423a92f04598bc39425bcc2b8ee46e"}, - {file = "rpds_py-0.18.0-cp38-none-win_amd64.whl", hash = "sha256:7cd863afe7336c62ec78d7d1349a2f34c007a3cc6c2369d667c65aeec412a5b1"}, - {file = "rpds_py-0.18.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:5307def11a35f5ae4581a0b658b0af8178c65c530e94893345bebf41cc139d33"}, - {file = "rpds_py-0.18.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:77f195baa60a54ef9d2de16fbbfd3ff8b04edc0c0140a761b56c267ac11aa467"}, - {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39f5441553f1c2aed4de4377178ad8ff8f9d733723d6c66d983d75341de265ab"}, - {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a00312dea9310d4cb7dbd7787e722d2e86a95c2db92fbd7d0155f97127bcb40"}, - {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f2fc11e8fe034ee3c34d316d0ad8808f45bc3b9ce5857ff29d513f3ff2923a1"}, - {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:586f8204935b9ec884500498ccc91aa869fc652c40c093bd9e1471fbcc25c022"}, - {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddc2f4dfd396c7bfa18e6ce371cba60e4cf9d2e5cdb71376aa2da264605b60b9"}, - {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ddcba87675b6d509139d1b521e0c8250e967e63b5909a7e8f8944d0f90ff36f"}, - {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7bd339195d84439cbe5771546fe8a4e8a7a045417d8f9de9a368c434e42a721e"}, - {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:d7c36232a90d4755b720fbd76739d8891732b18cf240a9c645d75f00639a9024"}, - {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6b0817e34942b2ca527b0e9298373e7cc75f429e8da2055607f4931fded23e20"}, - {file = "rpds_py-0.18.0-cp39-none-win32.whl", hash = "sha256:99f70b740dc04d09e6b2699b675874367885217a2e9f782bdf5395632ac663b7"}, - {file = "rpds_py-0.18.0-cp39-none-win_amd64.whl", hash = "sha256:6ef687afab047554a2d366e112dd187b62d261d49eb79b77e386f94644363294"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ad36cfb355e24f1bd37cac88c112cd7730873f20fb0bdaf8ba59eedf8216079f"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:36b3ee798c58ace201289024b52788161e1ea133e4ac93fba7d49da5fec0ef9e"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8a2f084546cc59ea99fda8e070be2fd140c3092dc11524a71aa8f0f3d5a55ca"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e4461d0f003a0aa9be2bdd1b798a041f177189c1a0f7619fe8c95ad08d9a45d7"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8db715ebe3bb7d86d77ac1826f7d67ec11a70dbd2376b7cc214199360517b641"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:793968759cd0d96cac1e367afd70c235867831983f876a53389ad869b043c948"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66e6a3af5a75363d2c9a48b07cb27c4ea542938b1a2e93b15a503cdfa8490795"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6ef0befbb5d79cf32d0266f5cff01545602344eda89480e1dd88aca964260b18"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1d4acf42190d449d5e89654d5c1ed3a4f17925eec71f05e2a41414689cda02d1"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a5f446dd5055667aabaee78487f2b5ab72e244f9bc0b2ffebfeec79051679984"}, - {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:9dbbeb27f4e70bfd9eec1be5477517365afe05a9b2c441a0b21929ee61048124"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:22806714311a69fd0af9b35b7be97c18a0fc2826e6827dbb3a8c94eac6cf7eeb"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:b34ae4636dfc4e76a438ab826a0d1eed2589ca7d9a1b2d5bb546978ac6485461"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c8370641f1a7f0e0669ddccca22f1da893cef7628396431eb445d46d893e5cd"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c8362467a0fdeccd47935f22c256bec5e6abe543bf0d66e3d3d57a8fb5731863"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11a8c85ef4a07a7638180bf04fe189d12757c696eb41f310d2426895356dcf05"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b316144e85316da2723f9d8dc75bada12fa58489a527091fa1d5a612643d1a0e"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf1ea2e34868f6fbf070e1af291c8180480310173de0b0c43fc38a02929fc0e3"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e546e768d08ad55b20b11dbb78a745151acbd938f8f00d0cfbabe8b0199b9880"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:4901165d170a5fde6f589acb90a6b33629ad1ec976d4529e769c6f3d885e3e80"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:618a3d6cae6ef8ec88bb76dd80b83cfe415ad4f1d942ca2a903bf6b6ff97a2da"}, - {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ed4eb745efbff0a8e9587d22a84be94a5eb7d2d99c02dacf7bd0911713ed14dd"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6c81e5f372cd0dc5dc4809553d34f832f60a46034a5f187756d9b90586c2c307"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:43fbac5f22e25bee1d482c97474f930a353542855f05c1161fd804c9dc74a09d"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d7faa6f14017c0b1e69f5e2c357b998731ea75a442ab3841c0dbbbfe902d2c4"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:08231ac30a842bd04daabc4d71fddd7e6d26189406d5a69535638e4dcb88fe76"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:044a3e61a7c2dafacae99d1e722cc2d4c05280790ec5a05031b3876809d89a5c"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3f26b5bd1079acdb0c7a5645e350fe54d16b17bfc5e71f371c449383d3342e17"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:482103aed1dfe2f3b71a58eff35ba105289b8d862551ea576bd15479aba01f66"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1374f4129f9bcca53a1bba0bb86bf78325a0374577cf7e9e4cd046b1e6f20e24"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:635dc434ff724b178cb192c70016cc0ad25a275228f749ee0daf0eddbc8183b1"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:bc362ee4e314870a70f4ae88772d72d877246537d9f8cb8f7eacf10884862432"}, - {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4832d7d380477521a8c1644bbab6588dfedea5e30a7d967b5fb75977c45fd77f"}, - {file = "rpds_py-0.18.0.tar.gz", hash = "sha256:42821446ee7a76f5d9f71f9e33a4fb2ffd724bb3e7f93386150b61a43115788d"}, -] - -[[package]] -name = "send2trash" -version = "1.8.3" -description = "Send file to trash natively under Mac OS X, Windows and Linux" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" -files = [ - {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, - {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, -] - -[package.extras] -nativelib = ["pyobjc-framework-Cocoa", "pywin32"] -objc = ["pyobjc-framework-Cocoa"] -win32 = ["pywin32"] - [[package]] name = "six" version = "1.16.0" @@ -2507,130 +720,21 @@ files = [ ] [[package]] -name = "soupsieve" -version = "2.5" -description = "A modern CSS selector implementation for Beautiful Soup." +name = "starlette" +version = "0.37.2" +description = "The little ASGI library that shines." optional = false python-versions = ">=3.8" files = [ - {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, - {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, -] - -[[package]] -name = "stack-data" -version = "0.6.3" -description = "Extract data from python stack frames and tracebacks for informative displays" -optional = false -python-versions = "*" -files = [ - {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, - {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, + {file = "starlette-0.37.2-py3-none-any.whl", hash = "sha256:6fe59f29268538e5d0d182f2791a479a0c64638e6935d1c6989e63fb2699c6ee"}, + {file = "starlette-0.37.2.tar.gz", hash = "sha256:9af890290133b79fc3db55474ade20f6220a364a0402e0b556e7cd5e1e093823"}, ] [package.dependencies] -asttokens = ">=2.1.0" -executing = ">=1.2.0" -pure-eval = "*" +anyio = ">=3.4.0,<5" [package.extras] -tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] - -[[package]] -name = "terminado" -version = "0.18.1" -description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." -optional = false -python-versions = ">=3.8" -files = [ - {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, - {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, -] - -[package.dependencies] -ptyprocess = {version = "*", markers = "os_name != \"nt\""} -pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} -tornado = ">=6.1.0" - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] -test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] -typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"] - -[[package]] -name = "tinycss2" -version = "1.2.1" -description = "A tiny CSS parser" -optional = false -python-versions = ">=3.7" -files = [ - {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, - {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, -] - -[package.dependencies] -webencodings = ">=0.4" - -[package.extras] -doc = ["sphinx", "sphinx_rtd_theme"] -test = ["flake8", "isort", "pytest"] - -[[package]] -name = "tomli" -version = "2.0.1" -description = "A lil' TOML parser" -optional = false -python-versions = ">=3.7" -files = [ - {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, - {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, -] - -[[package]] -name = "tornado" -version = "6.4" -description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." -optional = false -python-versions = ">= 3.8" -files = [ - {file = "tornado-6.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:02ccefc7d8211e5a7f9e8bc3f9e5b0ad6262ba2fbb683a6443ecc804e5224ce0"}, - {file = "tornado-6.4-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:27787de946a9cffd63ce5814c33f734c627a87072ec7eed71f7fc4417bb16263"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7894c581ecdcf91666a0912f18ce5e757213999e183ebfc2c3fdbf4d5bd764e"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43bc2e5370a6a8e413e1e1cd0c91bedc5bd62a74a532371042a18ef19e10579"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0251554cdd50b4b44362f73ad5ba7126fc5b2c2895cc62b14a1c2d7ea32f212"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fd03192e287fbd0899dd8f81c6fb9cbbc69194d2074b38f384cb6fa72b80e9c2"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:88b84956273fbd73420e6d4b8d5ccbe913c65d31351b4c004ae362eba06e1f78"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:71ddfc23a0e03ef2df1c1397d859868d158c8276a0603b96cf86892bff58149f"}, - {file = "tornado-6.4-cp38-abi3-win32.whl", hash = "sha256:6f8a6c77900f5ae93d8b4ae1196472d0ccc2775cc1dfdc9e7727889145c45052"}, - {file = "tornado-6.4-cp38-abi3-win_amd64.whl", hash = "sha256:10aeaa8006333433da48dec9fe417877f8bcc21f48dda8d661ae79da357b2a63"}, - {file = "tornado-6.4.tar.gz", hash = "sha256:72291fa6e6bc84e626589f1c29d90a5a6d593ef5ae68052ee2ef000dfd273dee"}, -] - -[[package]] -name = "traitlets" -version = "5.14.3" -description = "Traitlets Python configuration system" -optional = false -python-versions = ">=3.8" -files = [ - {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, - {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, -] - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] -test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] - -[[package]] -name = "types-python-dateutil" -version = "2.9.0.20240316" -description = "Typing stubs for python-dateutil" -optional = false -python-versions = ">=3.8" -files = [ - {file = "types-python-dateutil-2.9.0.20240316.tar.gz", hash = "sha256:5d2f2e240b86905e40944dd787db6da9263f0deabef1076ddaed797351ec0202"}, - {file = "types_python_dateutil-2.9.0.20240316-py3-none-any.whl", hash = "sha256:6b8cb66d960771ce5ff974e9dd45e38facb81718cc1e208b10b1baccbfdbee3b"}, -] +full = ["httpx (>=0.22.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.7)", "pyyaml"] [[package]] name = "typing-extensions" @@ -2644,101 +748,24 @@ files = [ ] [[package]] -name = "uri-template" -version = "1.3.0" -description = "RFC 6570 URI Template Processor" -optional = false -python-versions = ">=3.7" -files = [ - {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, - {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, -] - -[package.extras] -dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"] - -[[package]] -name = "urllib3" -version = "2.2.1" -description = "HTTP library with thread-safe connection pooling, file post, and more." -optional = false -python-versions = ">=3.8" -files = [ - {file = "urllib3-2.2.1-py3-none-any.whl", hash = "sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d"}, - {file = "urllib3-2.2.1.tar.gz", hash = "sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19"}, -] - -[package.extras] -brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] -h2 = ["h2 (>=4,<5)"] -socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] -zstd = ["zstandard (>=0.18.0)"] - -[[package]] -name = "wcwidth" -version = "0.2.13" -description = "Measures the displayed width of unicode strings in a terminal" -optional = false -python-versions = "*" -files = [ - {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, - {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, -] - -[[package]] -name = "webcolors" -version = "1.13" -description = "A library for working with the color formats defined by HTML and CSS." +name = "uvicorn" +version = "0.22.0" +description = "The lightning-fast ASGI server." optional = false python-versions = ">=3.7" files = [ - {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"}, - {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"}, + {file = "uvicorn-0.22.0-py3-none-any.whl", hash = "sha256:e9434d3bbf05f310e762147f769c9f21235ee118ba2d2bf1155a7196448bd996"}, + {file = "uvicorn-0.22.0.tar.gz", hash = "sha256:79277ae03db57ce7d9aa0567830bbb51d7a612f54d6e1e3e92da3ef24c2c8ed8"}, ] -[package.extras] -docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] -tests = ["pytest", "pytest-cov"] - -[[package]] -name = "webencodings" -version = "0.5.1" -description = "Character encoding aliases for legacy web content" -optional = false -python-versions = "*" -files = [ - {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, - {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, -] - -[[package]] -name = "websocket-client" -version = "1.7.0" -description = "WebSocket client for Python with low level API options" -optional = false -python-versions = ">=3.8" -files = [ - {file = "websocket-client-1.7.0.tar.gz", hash = "sha256:10e511ea3a8c744631d3bd77e61eb17ed09304c413ad42cf6ddfa4c7787e8fe6"}, - {file = "websocket_client-1.7.0-py3-none-any.whl", hash = "sha256:f4c3d22fec12a2461427a29957ff07d35098ee2d976d3ba244e688b8b4057588"}, -] +[package.dependencies] +click = ">=7.0" +h11 = ">=0.8" [package.extras] -docs = ["Sphinx (>=6.0)", "sphinx-rtd-theme (>=1.1.0)"] -optional = ["python-socks", "wsaccel"] -test = ["websockets"] - -[[package]] -name = "widgetsnbextension" -version = "4.0.10" -description = "Jupyter interactive widgets for Jupyter Notebook" -optional = false -python-versions = ">=3.7" -files = [ - {file = "widgetsnbextension-4.0.10-py3-none-any.whl", hash = "sha256:d37c3724ec32d8c48400a435ecfa7d3e259995201fbefa37163124a9fcb393cc"}, - {file = "widgetsnbextension-4.0.10.tar.gz", hash = "sha256:64196c5ff3b9a9183a8e699a4227fb0b7002f252c814098e66c4d1cd0644688f"}, -] +standard = ["colorama (>=0.4)", "httptools (>=0.5.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1)", "watchfiles (>=0.13)", "websockets (>=10.4)"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "f85acf75253bcc75631a57409c07ffb42fb8ab13bae86f103e5f1ecb4b4557cf" +content-hash = "c67ad07886d909cfac5f81e7822fd7ddae85b5f1b268b604aa531e24c752baeb" diff --git a/pyproject.toml b/pyproject.toml index f7cd499..2b9fa9e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,16 +1,17 @@ [tool.poetry] name = "ephemerality" -version = "1.1.1" +version = "2.0.0" description = "Module for computing ephemerality metrics for temporal activity vectors." -authors = ["Dmitry "] +authors = ["Dmitry Gnatyshak "] readme = "README.md" [tool.poetry.dependencies] python = "^3.10" numpy = "^1.24.2" -pydantic = "^2.7.0" +pydantic = "^2.7.1" matplotlib = "^3.8.4" -jupyter = "^1.0.0" +fastapi = "^0.110.2" +uvicorn = "^0.22.0" [build-system] requires = ["poetry-core"] diff --git a/requirements-rest.txt b/requirements-rest.txt deleted file mode 100644 index a488c44..0000000 --- a/requirements-rest.txt +++ /dev/null @@ -1,2 +0,0 @@ -fastapi~=0.110.0 -uvicorn~=0.21.1 diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index c569fb9..0000000 --- a/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -numpy~=1.24.2 -setuptools~=67.6.1 -pydantic~=1.10.7 diff --git a/setup.py b/setup.py deleted file mode 100644 index 090b548..0000000 --- a/setup.py +++ /dev/null @@ -1,40 +0,0 @@ -import os -from setuptools import setup -import re - -VERSION_FILE = "ephemerality/_version.py" -VERSION_REGEX = r"^__version__ = ['\"]([^'\"]*)['\"]" - - -def read(file_name): - return open(os.path.join(os.path.dirname(__file__), file_name), 'rt', encoding="utf8").read() - - -version_lines = open(VERSION_FILE, 'r').read() -match = re.search(VERSION_REGEX, version_lines, re.M) -if match: - version = match.group(1) -else: - raise RuntimeError("Unable to find version string in %s." % (VERSION_FILE,)) - -with open('requirements.txt', 'r') as f: - requirements = list(f.read().splitlines()) - -with open('requirements-rest.txt', 'r') as f: - requirements_rest = list(f.read().splitlines()) - -setup( - name='ephemerality', - version=version, - packages=['ephemerality'], - url='https://github.com/HPAI-BSC/ephemerality', - license='MIT', - license_files=['./LICENSE'], - author='HPAI BSC', - author_email='dmitry.gnatyshak@bsc.es', - description='Module for computing ephemerality metrics for temporal activity vectors.', - long_description=read('README.md'), - scripts=[], - install_requires=requirements, - extras_require={'rest':requirements_rest} -) diff --git a/testing/src/test_ephemerality.py b/testing/src/test_ephemerality.py index d9f5261..cca1727 100644 --- a/testing/src/test_ephemerality.py +++ b/testing/src/test_ephemerality.py @@ -1,8 +1,15 @@ +import json +import time from unittest import TestCase, TextTestRunner import numpy as np -from typing import Sequence +from typing import Sequence, Iterable, Literal +from typing_extensions import Self +from itertools import chain, combinations +import subprocess +import sys +import requests from testing.src.test_utils import EphemeralityTestCase -from ephemerality import compute_ephemerality, EphemeralitySet +from ephemerality import compute_ephemerality, EphemeralitySet, InputData DEFAULT_TEST_CASES = [ @@ -653,24 +660,102 @@ ] +class PartialCoresIterator: + _core_types = ('l', 'm', 'r', 's') + + def __init__(self, expected_output_full: EphemeralitySet) -> None: + self._expected_output_full = expected_output_full + self._chain = None + + def __iter__(self) -> Self: + self._chain = chain.from_iterable(combinations(self._core_types, r) for r in range(1, len(self._core_types) + 1)) + return self + + def __next__(self) -> tuple[str, EphemeralitySet]: + subset = next(self._chain) + return ''.join(subset), self._eph_subset(subset) + + def _eph_subset(self, types: Iterable[str]) -> EphemeralitySet: + eph_set = EphemeralitySet() + for core_type in types: + match core_type: + case 'l': + eph_set.len_left_core = self._expected_output_full.len_left_core + eph_set.eph_left_core = self._expected_output_full.eph_left_core + case 'm': + eph_set.len_middle_core = self._expected_output_full.len_middle_core + eph_set.eph_middle_core = self._expected_output_full.eph_middle_core + case 'r': + eph_set.len_right_core = self._expected_output_full.len_right_core + eph_set.eph_right_core = self._expected_output_full.eph_right_core + case 's': + eph_set.len_sorted_core = self._expected_output_full.len_sorted_core + eph_set.eph_sorted_core = self._expected_output_full.eph_sorted_core + case _: + raise ValueError('Invalid core type!') + return eph_set + + def __len__(self): + return len(self._chain) + + class TestComputeEphemerality(TestCase): test_cases: Sequence[EphemeralityTestCase] = DEFAULT_TEST_CASES def test_compute_ephemeralities(self): + print('IN-SCRIPT-BASED TEST') + self.run_test('python') + + def test_cmd(self): + print('CMD-BASED TEST') + self.run_test('cmd') + + def test_api(self): + print('API-BASED TEST') + rest_server = subprocess.Popen( + [f'{sys.executable}', '-m', 'ephemerality', 'api'], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT + ) + time.sleep(5) + self.run_test('api') + rest_server.terminate() + rest_server.wait() + + def run_test(self, run_type: Literal['python', 'cmd', 'api'] = 'python'): for i, test_case in enumerate(self.test_cases): + if run_type == 'cmd' and len(test_case.input_sequence) > 100: + continue with self.subTest(): - print(f'Running test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') + print(f'Running test case {i}: {test_case.input_sequence}, threshold {test_case.threshold}...') + + partial_output_iterator = PartialCoresIterator(test_case.expected_output) + for core_types, expected_output in partial_output_iterator: + print(f'\tCore subset \"{core_types}\"...') - actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, - threshold=test_case.threshold) + match run_type: + case 'cmd': + actual_output = subprocess.check_output([ + f'{sys.executable}', '-m', 'ephemerality', 'cmd', # f'{Path(root_dir) / "ephemerality"}' + " ".join([str(freq) for freq in test_case.input_sequence]), + '-t', str(test_case.threshold), + '-c', core_types + ]).decode('utf-8') + actual_output = EphemeralitySet(**json.loads(actual_output)) + case 'python': + actual_output = compute_ephemerality(activity_vector=test_case.input_sequence, + threshold=test_case.threshold, + types=core_types) + case 'api': + request_data = InputData(input_sequence=test_case.input_sequence, threshold=test_case.threshold) + response = requests.get(f'http://127.0.0.1:8080/ephemerality/all?core_types={core_types}', json=[request_data.model_dump()]) + actual_output = EphemeralitySet(**json.loads(response.content)[0]['output']) - try: - self.assertEquals(test_case.expected_output, actual_output) - except AssertionError as ex: - print(f"\tAssertion error while processing test case {i}: {test_case.input_sequence}, " - f"threshold {test_case.threshold}...") - print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") - raise ex + try: + self.assertEqual(expected_output, actual_output) + except AssertionError as ex: + print(f"\tAssertion error while processing test case {i}.{core_types}: {test_case.input_sequence}, " + f"threshold {test_case.threshold}...") + print(f"\t\tExpected output: {test_case.expected_output}\n\t\tActual output: {actual_output}") + raise ex def test_ephemerality(test_cases: list[EphemeralityTestCase] | None = None) -> None: