From a3c1559475232ff1cc1c4585f3ebe03ada946902 Mon Sep 17 00:00:00 2001 From: Ludwig Neste <31670556+The-Ludwig@users.noreply.github.com> Date: Wed, 10 Jan 2024 12:41:11 -0500 Subject: [PATCH] Get ready for 1.0.0 release (#98) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Upate documentaiton * Add examples * Switch documentation theme to pydata. * Add tutorial * Make some functions "private" * Progress Bar is now optional * Make `CorsikaRunner` be usable inside a context-manager (`with`-statement) * Add compression (level 5) when exporting to hdf5 * Bump version number to 1.0.0 🎉 --- .codespell-ignore | 1 + .gitignore | 2 + .pre-commit-config.yaml | 4 + CONTRIBUTING.md | 10 + README.md | 160 +- docs/api.rst | 24 +- docs/conf.py | 37 +- docs/examples.rst | 9 + docs/examples/complete.ipynb | 782 +++++++++ docs/examples/plot_spectrum.ipynb | 368 ++++ docs/index.rst | 51 +- docs/introduction.md | 103 ++ docs/requirements.txt | 5 +- .../{nbstreamreader.py => _nbstreamreader.py} | 7 +- panama/cli/corsika_to_hdf5.py | 13 +- panama/cli/run.py | 6 +- panama/constants.py | 3 + panama/prompt.py | 10 +- panama/read.py | 11 +- panama/run.py | 195 ++- panama/version.py | 2 +- panama/weights.py | 44 +- pdm.lock | 1531 ++++++++++++++--- pyproject.toml | 8 +- tests/test_meta.py | 1 + tests/test_run.py | 36 + 26 files changed, 3022 insertions(+), 401 deletions(-) create mode 100644 docs/examples.rst create mode 100644 docs/examples/complete.ipynb create mode 100644 docs/examples/plot_spectrum.ipynb create mode 100644 docs/introduction.md rename panama/{nbstreamreader.py => _nbstreamreader.py} (89%) diff --git a/.codespell-ignore b/.codespell-ignore index 10a8e48..2728740 100644 --- a/.codespell-ignore +++ b/.codespell-ignore @@ -1,2 +1,3 @@ # PAN*das* A*nd* M*ulticore utils for corsik*A*7* ,-.----. ,--.das nd ____ ulticore utils for corsik 7 + ,-.----. ,--.das nd ____ ulticore utils for corsik 7 diff --git a/.gitignore b/.gitignore index 7ba7cf6..ed1e6d3 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,5 @@ dist/ corsika_output/ corsika-*/ corsika-*.tar.gz +node_modules/ +.ipynb_checkpoints/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 128ae29..ebf18bc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -37,6 +37,10 @@ repos: rev: v2.2.6 hooks: - id: codespell + exclude: > + (?x)^( + .*\.ipynb + )$ args: [--exclude-file, .codespell-ignore] - repo: https://github.com/pre-commit/pygrep-hooks diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 62a873e..c2f0ed3 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -31,3 +31,13 @@ eval $(pdm venv activate in-project) ```bash pdm run $SHELL ``` + +# Conventions + +This project tries to stay compatible with the suggestions from [Scikit hep](https://learn.scientific-python.org/development/guides/repo-review/?repo=The-Ludwig%2Fpanama&branch=main). +The used code style is [black](https://github.com/psf/black). +Please also obey to the other [pre-commit hooks](https://pre-commit.com/) and install them via + +```bash +pre-commit install +``` diff --git a/README.md b/README.md index bf267e6..28e5838 100644 --- a/README.md +++ b/README.md @@ -15,147 +15,89 @@ `---` '---' '---' ``` +PANAMA - A python toolkit for [CORSIKA7](https://www.iap.kit.edu/corsika/index.php). + [![Read the Docs](https://img.shields.io/readthedocs/panama?style=for-the-badge)](https://panama.readthedocs.io/en/latest/) + [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/The-Ludwig/PANAMA/ci.yml?style=for-the-badge)](https://github.com/The-Ludwig/PANAMA/actions/workflows/ci.yml) +[![GitHub issues](https://img.shields.io/github/issues-raw/The-Ludwig/PANAMA?style=for-the-badge)](https://github.com/The-Ludwig/PANAMA/issues) [![Codecov](https://img.shields.io/codecov/c/github/The-Ludwig/PANAMA?label=test%20coverage&style=for-the-badge)](https://app.codecov.io/gh/The-Ludwig/PANAMA) + [![PyPI](https://img.shields.io/pypi/v/corsika-panama?style=for-the-badge)](https://pypi.org/project/corsika-panama/) [![DOI](https://img.shields.io/badge/DOI-10.5281%20%2F%20zenodo.10210623-blue.svg?style=for-the-badge)](https://doi.org/10.5281/zenodo.10210623) - -[![GitHub issues](https://img.shields.io/github/issues-raw/The-Ludwig/PANAMA?style=for-the-badge)](https://github.com/The-Ludwig/PANAMA/issues) [![GitHub](https://img.shields.io/github/license/The-Ludwig/PANAMA?style=for-the-badge)](https://github.com/The-Ludwig/PANAMA/blob/main/LICENSE) [![Codestyle](https://img.shields.io/badge/codesyle-Black-black.svg?style=for-the-badge)](https://github.com/psf/black) -## Installation - -```bash -pip install corsika-panama -``` - -If you want to convert Corsikas DAT files to HDF5 files, you need to install the optional `hdf` dependency - -``` -pip install corsika-panama[hdf] -``` - ## Features -### Run CORSIKA7 on multiple cores +This python package provides multiple features -- each feature can be used independently, but they also work great together. -You need to have [`CORSIKA7`](https://www.iap.kit.edu/corsika/79.php) installed to run this. +- Execute CORSIKA7 on multiple cores +- Read CORSIKA7 DAT files ("particle files") to [pandas DataFrames](https://pandas.pydata.org/docs/) + - Correctly parse output from the `EHIST` option +- Calculate weights for a multiple primary spectra -Running 100 showers on 4 cores with primary being proton: +To see some examples on how to use panama, see the introduction in the documentation. +To get an overview of how the features play together, have a look at the example notebook in the documentation. +In-depth explanation is provided in the API documentation. -```sh -$ panama run --corsika path/to/corsika7/executable -j4 ./tests/files/example_corsika.template -83%|████████████████████████████████████████████████████▋ | 83.0/100 [00:13<00:02, 6.36shower/s] -Jobs should be nearly finished, now we wait for them to exit -All jobs terminated, cleanup now -``` - -Injecting 5 different primaries (Proton, Helium-4, Carbon-12, Silicon-28, Iron-54 roughly aligning with grouping in H3a) with each primary shower taking 10 jobs: +## Installation -```sh -$ panama run --corsika corsika-77420/run/corsika77420Linux_SIBYLL_urqmd --jobs 10 --primary ""{2212: 500, 1000020040: 250, 1000060120: 50, 1000140280: 50, 1000260540: 50}"" ./tests/files/example_corsika.template -,-.----. ,--.das nd ____ ulticore utils for corsik 7 -\ / \ ,---, ,--.'| ,---, ,' , `. ,---, -| : \ ' .' \ ,--,: : | ' .' \ ,-+-,.' _ | ' .' \ -| | .\ : / ; '. ,`--.'`| ' : / ; '. ,-+-. ; , || / ; '. -. : |: |: : \ | : : | |: : \ ,--.'|' | ;| : : \ -| | \ :: | /\ \ : | \ | :: | /\ \ | | ,', | ': : | /\ \ -| : . /| : ' ;. : | : ' '; || : ' ;. : | | / | | || | : ' ;. : -; | |`-' | | ;/ \ \' ' ;. ;| | ;/ \ \' | : | : |, | | ;/ \ \ -| | ; ' : | \ \ ,'| | | \ |' : | \ \ ,'; . | ; |--' ' : | \ \ ,' -: ' | | | ' '--' ' : | ; .'| | ' '--' | : | | , | | ' '--' -: : : | : : | | '`--' | : : | : ' |/ | : : -| | : | | ,' ' : | | | ,' ; | |`-' | | ,' -`---'.| `--'' ; |.' `--'' | ;/ `--'' - `---` '---' '---' v0.7.2 -... +```bash +pip install corsika-panama ``` -### Read CORSIKA7 DAT files to pandas dataframes - -Example: Calculate mean energy in the corsika files created in the example above: - -``` -In [1]: import panama as pn +If you want to convert Corsikas DAT files to HDF5 files, you need to install the optional `hdf` dependency -In [2]: run_header, event_header, particles = pn.read_DAT(glob="corsika_output/DAT*") -100%|████████████████████████████████████████████████████████████| 2000/2000.0 [00:00<00:00, 10127.45it/s] -In [3]: particles["energy"].mean() -Out[3]: 26525.611020413744 ``` - -`run_header`, `event_header` and `particles` are all [pandas.DataFrames](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) and can conveniently be used. - -If `CORSIKA7` is compiled with the `EHIST` option, then the mother particles are automatically deleted, by default (this behaviour can be changed with`drop_mothers=False`). -If you want additional columns in the real particles storing the mother information use `mother_columns=True`. - -### Convert CORSIKA7 DAT files to hdf5 files - -For this you need to have [PyTables](https://github.com/PyTables/PyTables) installed. -You can do that if via `pip install corsika-panama[hdf]`. - -```sh -$ panama hdf5 path/to/corsika/dat/files/DAT* output.hdf5 +pip install corsika-panama[hdf] ``` -The data is available under the `run_header` `event_header` and `particles` key. +### CORSIKA7 -### Weighting to primary spectrum - -This packages also provides facility to add a `weight` column to the dataframe, so you can look at corsika-output -in physical flux in terms of $(\mathrm{m^2} \mathrm{s}\ \mathrm{sr}\ \mathrm{GeV})^{-1}$. -Using the example above, to get the whole physical flux in the complete simulated energy region: - -``` -In [1]: import panama as pn +For usage and installation of CORSIKA7, please refer to [its website](https://www.iap.kit.edu/corsika/index.php) and its [userguide](https://www.iap.kit.edu/corsika/downloads/CORSIKA_GUIDE7.7500.pdf). +To properly use this package, knowledge of CORSIKA7 is required. -In [2]: run_header, event_header, particles = pn.read_DAT(glob="corsika_output/DAT*") -100%|████████████████████████████████████████████████████████████| 2000/2000.0 [00:00<00:00, 10127.45it/s] -In [3]: pn.add_weight(run_header, event_header, particles) - -In [4]: particles["weight"].sum()*(run_header["energy_max"]-run_header["energy_min"]) -Out[4]: -run_number -1.0 1234.693481 -0.0 1234.693481 -3.0 1234.693481 -2.0 1234.693481 -dtype: float32 +If you want to install CORSIKA7, you need to request access to their CORSIKA7 mailing list, [as described on their website](https://www.iap.kit.edu/corsika/79.php), then you will receive the CORSIKA7 +password. +If you want to skip the process of getting familiar with the software and compiling it with coconut, panama provides a (linux) script for compiling +it. +You will need a `fortran` compiler. CORSIKA7 will then be pre-configured with the curved earth, EHIST, SIBYLL2.3d and URQDM options. +For finer control over the used options, please compile CORSIKA7 yourself. +After cloning this repository, you can then execute +```bash +CORSIKA_VERSION=77500 CORSIKA_PW=CORSIKA_PASSWORD_YOU_WILL_RECEIVE_BY_MAIL admin/download_corsika.sh ``` -Which is in units of $(\mathrm{m^2}\ \mathrm{s}\ \mathrm{sr})^{-1}$. We get a result for each run, since -in theory we could have different energy regions. Here, we do not, so the result is always equal. +which will download and compile CORSIKA7 version 77500. +If you are interested in automatically testing software using CORSIKA7, using GitHub actions, +have a look at the `.github` folder of this project in combination with the admin script. -Weighting can be applied to different primaries, also, if they are known by the flux model. +## Contributing -`add_weight` can also be applied to dataframes loaded in from hdf5 files produced with PANAMA. +Contributions and suggestions are very welcome. +Feel free to open an [issue](https://github.com/The-Ludwig/PANAMA/issues) or [pull request](https://github.com/The-Ludwig/PANAMA/pulls). +This project uses [pdm](https://pdm-project.org/latest/) for the build system as well as a +dependency and virtual environment manager. +For suggestions on how to set up a development environment, have a look at `CONTRIBUTING.md`. -TODO: Better documentation of weighting (what is weighted, how, proton/neutrons, area...?) +## Further Notes -## Name +This project tries to stay compatible with the suggestions from [Scikit hep](https://learn.scientific-python.org/development/guides/repo-review/?repo=The-Ludwig%2Fpanama&branch=main). Naming idea goes back to [@Jean1995](https://github.com/Jean1995), thanks for that! -He originally proposed "PArallel ruN of corsikA on MAny Cores", as +He originally proposed "PArallel ruN of corsikA on MAny cores", as the scope of this library grew bigger, it evolved into the current name. -#### Notes: - -This started a little while ago while I was looking into the `EHIST` option -of corsika. -I wanted a way of conveniently running CORSIKA7 on more than 1 core. -I ended in the same place where most CORSIKA7 users end (see e.g. [fact-project/corsika_wrapper](https://github.com/fact-project/corsika_wrapper)) -and wrote a small wrapper. - -read_DAT made possible by [cta-observatory/pycorsikaio](https://github.com/cta-observatory/pycorsikaio). - -#### Pitfalls - -- The whole `run` folder of CORSIKA7 must be copied for each process, so very high parallel runs have high overhead -- If you simulate to low energies, python can't seem to hold up with the corsika output to `stdin` and essentially slows down corsika this is still a bug in investigation #1 +This started as part of the code I wrote for [my master thesis](https://ludwigneste.space/masterthesis_ludwig_neste.pdf). +I ended in the same place where most CORSIKA7 users end when running large CORSIKA7 simulations and wrote small scripts +to split one simulation request into multiple CORSIKA7 processes with different seeds. +The FACT software ([fact-project/corsika_wrapper](https://github.com/fact-project/corsika_wrapper)) +and the IceCube software does essentially the same thing (and I am sure, MAGIC, CTA and other air-shower based observatories do the same). +I hope this package provides a more experiment-independent and better documented version of internal software packages. -## What this is not +## Related Repositories -Bug-free or stable +- Reading DAT files uses [cta-observatory/pycorsikaio](https://github.com/cta-observatory/pycorsikaio). +- Cosmic Ray models implemented in [The-Ludwig/FluxComp](https://github.com/The-Ludwig/FluxComp/). diff --git a/docs/api.rst b/docs/api.rst index f8bcbf2..028dfb1 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -1,15 +1,27 @@ API Documentation ================== +panama (re-exported from submodules) +------------------------------------ .. automodule:: panama :members: -Fluxes -------- +panama.prompt +------------- +.. automodule:: panama.prompt + :members: + +panama.read +----------- +.. automodule:: panama.read + :members: -The fluxes here are the `mceq-project/crflux `_ -implementations, with very slight modifications to make them faster when working with -numpy/pandas. +panama.run +---------- +.. automodule:: panama.run + :members: -.. automodule:: panama.fluxes +panama.weights +-------------- +.. automodule:: panama.weights :members: diff --git a/docs/conf.py b/docs/conf.py index 42182a5..39e0dd5 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -5,24 +5,25 @@ # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information +import panama project = "PANAMA" -copyright = "2023, Ludwig Neste" +copyright = "2023-2024, Ludwig Neste" author = "Ludwig Neste" -release = "v0.3.0" +release = panama.__version__ # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ - "m2r2", - "sphinx_rtd_theme", + "nbsphinx", + "myst_parser", "sphinx.ext.napoleon", "sphinx.ext.autodoc", "sphinx_click", + "pydata_sphinx_theme", ] - -templates_path = ["_templates"] +# templates_path = ["_templates"] exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] source_suffix = [".rst", ".md"] @@ -31,5 +32,25 @@ # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output -html_theme = "sphinx_rtd_theme" -html_static_path = ["_static"] +html_theme = "pydata_sphinx_theme" +html_theme_options = { + # "logo": { + # "text": "My awesome documentation", + # }, + "collapse_navigation": False, + "show_nav_level": 3, + "show_toc_level": 3, + "secondary_sidebar_items": [], +} +# html_static_path = ["_static"] +html_sidebars = {"**": ["page-toc", "sidebar-nav-bs", "sidebar-ethical-ads"]} + + +# -- Autodoc options +autodoc_default_options = { + "members": True, + "member-order": "bysource", + "special-members": "__init__", + "undoc-members": True, + "exclude-members": "__weakref__", +} diff --git a/docs/examples.rst b/docs/examples.rst new file mode 100644 index 0000000..89d2507 --- /dev/null +++ b/docs/examples.rst @@ -0,0 +1,9 @@ +Examples +======== + +.. toctree:: + :maxdepth: 1 + :caption: Contents: + + examples/plot_spectrum.ipynb + examples/complete.ipynb diff --git a/docs/examples/complete.ipynb b/docs/examples/complete.ipynb new file mode 100644 index 0000000..0de93f4 --- /dev/null +++ b/docs/examples/complete.ipynb @@ -0,0 +1,782 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5b3a36db-128b-4e0b-8935-6e3b8dc1ecf2", + "metadata": {}, + "source": [ + "# Full Tutorial\n", + "\n", + "This notebook aims to show all the features of `panama`, and especially how they interplay." + ] + }, + { + "cell_type": "markdown", + "id": "816507ed-8796-494d-a184-4b6fae0382fa", + "metadata": {}, + "source": [ + "## Installation\n", + "Installing `panama` is easy, just run \n", + "```bash\n", + "pip install corsika-panama\n", + "```\n", + "Or install it by cloning, so you also have access to the install script for CORSIKA7.\n", + "```bash\n", + "git clone git@github.com:The-Ludwig/PANAMA.git\n", + "cd PANAMA\n", + "pip install -e .\n", + "```\n", + "\n", + "### CORSIKA7\n", + "For this notebook to make sense, you need a CORSIKA7 installation (preferably with the `EHIST` option). \n", + "If you cloned the `panama` repository in the last step, you can easily download and install a pre-configured version (EHIST, SIBYLL2.3d, CURVED, URQDM) of CORSIKA7. You need to have a FORTRAN compiler installed:\n", + "```\n", + "CORSIKA_VERSION=77500 CORSIKA_PW= admin/download_corsika.sh\n", + "```\n", + "This will install CORSIKA7 in the folder `corsika-77500`. You oviously need the CORSIKA_PW, which you will get by mail, after requesting to be on the CORSIKA7 mailing list, [as described on their website here](https://www.iap.kit.edu/corsika/79.php)." + ] + }, + { + "cell_type": "markdown", + "id": "170a3fa3-a0ca-4bc1-abcb-cf878243937e", + "metadata": {}, + "source": [ + "## Generating a CORSIKA7 Muon Simulation\n", + "`panama` provides two ways of executing CORSIKA7 (in parallel). You can either use the Command Line Interface (CLI), available through `panama run` after installation, or you can do it inside python via an `CorsikaRunner` object.\n", + "The CLI itself is only a small wrapper around `panama.CorsikaRunner`. This tutorial focuses on the use of `CorsikaRunner`, but translating the code to a `panama` command, is straightforeward. For that, have a look at `panama run --help`.\n", + "\n", + "### CORSIKA Steering Cards\n", + "Now that you have a workin CORSIKA7 simulation, you need to tell CORSIKA what settings to use. The current version of `panama` follows the philosphy to controll CORSIKA7 exactly as you would when using CORSIKA7 directly -- Except for the necesarry modifications for parallelization to work; This means that you have to write a CORSIKA7 steering card. Consider the following example\n", + "```\n", + "RUNNR {run_idx} run number\n", + "EVTNR {first_event_idx} number of first shower event\n", + "NSHOW {n_show} number of showers to generate\n", + "PRMPAR {primary} particle type of prim. particle\n", + "ESLOPE -1 slope of primary energy spectrum\n", + "ERANGE 1.E4 1.E9 energy range of primary particle\n", + "THETAP 0. 0. range of zenith angle (degree)\n", + "PHIP -180. 180. range of azimuth angle (degree)\n", + "SEED {seed_1} 0 0 seed for 1. random number sequence\n", + "SEED {seed_2} 0 0 seed for 2. random number sequence\n", + "OBSLEV 110.E2 observation level (in cm)\n", + "FIXCHI 0. starting altitude (g/cm**2)\n", + "MAGNET 16.811 -51.890 magnetic field at south pole (IceCube)\n", + "HADFLG 0 0 0 0 0 2 flags hadr.interact.&fragmentation\n", + "ECUTS 1.0E3 1.0E3 1.0E20 1.0E20 energy cuts for particles\n", + "MUADDI T additional info for muons\n", + "MUMULT T muon multiple scattering angle\n", + "ELMFLG T T em. interaction flags (NKG,EGS)\n", + "STEPFC 1.0 mult. scattering step length fact.\n", + "RADNKG 200.E2 outer radius for NKG lat.dens.distr.\n", + "LONGI F 10. F F longit.distr. & step size & fit & out\n", + "MAXPRT 1 max. number of printed events\n", + "DIRECT {dir} output directory\n", + "USER you user\n", + "DEBUG F 6 F 1000000 debug flag and log.unit for out\n", + "EXIT terminates input\n", + "```\n", + "For explanation what each setting does specifically, refer to the [CORSIKA7 userguide](https://web.iap.kit.edu/corsika/usersguide/usersguide.pdf).\n", + "The important thing is, that `panama` replaces `{run_idx}, {first_event_idx}, {n_show}, {primary}, {seed_1}, {seed_2}` and `{dir}` correctly for parallelization.\n", + "In theory, `panama` works when only providing `{run_idx}, {n_show}, {seed_1}, {seed_2}`, although it is adviced to leave the other templates in the card, as only then the full functionality of `panama` is available. \n", + "\n", + "**TLDR;** You can use every normal CORSIKA7 steering card, as long as you add at least `{run_idx}, {n_show}, {seed_1}, {seed_2}` at the arguments as in the card above, and optionally (but required for `panama` to work as expected) `{first_event_idx}, {primary}, {dir}`." + ] + }, + { + "cell_type": "markdown", + "id": "2e0bdaa2-722e-4169-a749-3dfb0768ead1", + "metadata": {}, + "source": [ + "### Starting the CORSIKA Simulation\n", + "This notebook will use the CORSIKA7 Steering card from above, which is located in the `panama` repository under `tests/files`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fd707804-c284-45f2-bb2b-6a32b318a0d1", + "metadata": {}, + "outputs": [], + "source": [ + "import panama as pn\n", + "\n", + "# This is to have convenient access to the PDGIDs\n", + "from particle import Particle, literals\n", + "from pathlib import Path" + ] + }, + { + "cell_type": "markdown", + "id": "ce056adb-cdfb-4935-83a1-78d5e250c4e9", + "metadata": {}, + "source": [ + "The following cell performs the CORSIKA7 simulation. On my laptop with an AMD Ryzen 7 5700U CPU with 8 Physical cores (and 16 threads),\n", + "the simulation took about 13 minutes with 15 threads. Consider changing n_jobs to a suitable value for your set up.\n", + "\n", + "remember to execute `rm -r corsika_output`, should you want to re-run the cell. This is not done automatically by `panama`, since deleting simulations, might come at a heavy cost and should always be done manually. (I speak from experience! :0)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b4331497-73a8-433a-aa14-e8dc43c1fc17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulations exist, I will reuse them, instead of generating new ones.\n" + ] + } + ], + "source": [ + "if Path(\"./corsika_output/\").exists():\n", + " print(\"Simulations exist, I will reuse them, instead of generating new ones.\")\n", + "else:\n", + " # Run 1000 Showers each with the 4 leading elements of the GSF CR flux model\n", + " # This is done in a context-manager, alternatively, you could also just construct an object\n", + " # and call \"clean\"\n", + " with pn.CorsikaRunner(\n", + " primary={\n", + " literals.proton.pdgid: 1000,\n", + " Particle.from_nucleus_info(z=2, a=4).pdgid: 1000, # Helium-4\n", + " Particle.from_nucleus_info(z=8, a=16).pdgid: 1000, # Oxygen-16\n", + " Particle.from_nucleus_info(z=26, a=56).pdgid: 1000, # Iron-56\n", + " },\n", + " n_jobs=15, # Number of jobs to submit to the OS\n", + " template_path=\"../../tests/files/example_corsika.template\", # This is the steering card from above\n", + " output=\"./corsika_output\", # Produced DAT files go here\n", + " corsika_executable=\"../../corsika-77500/run/corsika77500Linux_SIBYLL_urqmd\", # path to the compiled corsika exectuble\n", + " corsika_tmp_dir=\"/tmp/corsika_tmp_dir/\", # some temporary path,\n", + " seed=1701,\n", + " ) as runner:\n", + " runner.run()" + ] + }, + { + "cell_type": "markdown", + "id": "956800ab-f486-41b4-a8c8-b608481ec302", + "metadata": {}, + "source": [ + "### Reading in the Simulation\n", + "The following cell reads in the simulated data, and puts it to three pandas DataFrames.\n", + "`run_header` contains the information from corsikas RUN HEADER, `event_header` that from corsikas EVENT HEADER,\n", + "and `particles` is a list of all simulated particles reaching the ground level.\n", + "Since we simulated with `EHIST`, `panama` could read in the history information correctly, and with `mother_columns=True` add the \n", + "information to each particle column-wise. With the default options, the particles DataFrame does not contain the mother particles, only \n", + "ground level particles. For further options, have a look at its documentation.\n", + "\n", + "`panama` makes use of pandas MultiIndex (for better or worse). This means, that the index of run_header is a single number (`run_number`), while \n", + "the index of event_header is two numbers (`run_number`, `event_number`). Finally, particle has a three-touple index (`run_number`, `event_number`, `particle_number`). \n", + "The use of pandas MultiIndex allows syntax like `particles[\"primary_energy\"] = event_number[\"total_energy\"]` to work as expected. At times, it can be confusing, though. You can then consider to also add them as normal columns with `particles[\"run_idx\"] = particles.index.get_level_values(0)`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "09d2beae-2cb8-45b4-a0e7-f1d8c989e293", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4000/4000.0 [00:00<00:00, 14886.29it/s]\n" + ] + } + ], + "source": [ + "run_header, event_header, particles = pn.read_DAT(\n", + " glob=\"corsika_output/DAT*\", mother_columns=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "50eeb5ca-8ba5-49e2-ab71-176c420b401f", + "metadata": {}, + "source": [ + "Let's see what the simulated data looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e0718c5f-ab3f-47af-9522-566d6c512d1f", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e7675469-342a-4cbe-8cf1-ad6f3efd2e2c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Particle Type')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's see what kind of particles we have in the simulation\n", + "counts = particles[\"pdgid\"].value_counts()\n", + "counts.index = counts.index.map(\n", + " lambda pid: f\"{Particle.from_pdgid(pid).name} ({pid})\"\n", + " if pid != 0\n", + " else \"unknown (0)\"\n", + ")\n", + "counts.plot(kind=\"bar\", log=True)\n", + "\n", + "plt.ylabel(\"Counts\")\n", + "plt.xlabel(\"Particle Type\")" + ] + }, + { + "cell_type": "markdown", + "id": "03cf37a4-21a1-4684-9e8a-31eb4e3f0d8c", + "metadata": {}, + "source": [ + "With the `EHIST` option, we can have some fun and look from which decays the negatively charged muons are coming from." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5bb4ba43-cca1-492d-89fc-897271766e1e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Parent Particle')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sel = particles.query(\"pdgid == 13\")\n", + "\n", + "counts = sel.mother_pdgid_cleaned.value_counts()\n", + "counts.index = counts.index.map(\n", + " lambda pid: f\"{Particle.from_pdgid(pid).name} ({pid})\"\n", + " if pid != 0\n", + " else \"unknown (0)\"\n", + ")\n", + "counts.plot(kind=\"bar\", log=True)\n", + "\n", + "plt.ylabel(\"$\\mu^-$ Counts\")\n", + "plt.xlabel(\"Parent Particle\")" + ] + }, + { + "cell_type": "markdown", + "id": "78d0fed8-445f-4b93-a91e-c50dbdc9e462", + "metadata": {}, + "source": [ + "Here we see the big caviat of CORSIKA7's EHIST option: For a lot of particles (most probably only pions), it can't really tell the direct parent particle of the muon, so it get's classified as \"unknown\", with the non-existing pdgid 0.\n", + "It is important to use the column \"mother_pdgid_cleaned\" instead of \"mother_pdgid\", since EHIST is providing particles further up in the decay chain, then the direct parent and indicates this via the \"Hadron Generation Counter\". `panama` properly parses this and applies it in the `_cleaned` columns of the DataFrame.\n", + "**TLDR;** Unkowm are (most likely) either `\\pi^+` or `\\pi^-` mesons, remember to use `mother_pdgid_cleaned` instead of `mother_pdgid`.\n", + "\n", + "\n", + "Let's plot an energy distribution of the muons in the simulation:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "dc51f889-a6fd-4182-9c07-97b436911f06", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select all muons and anti-muons and histogram their energy\n", + "e = particles.query(\"pdgid in (13, -13)\")[\"energy\"]\n", + "\n", + "# Create new plot\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Use logarithmically sized bins\n", + "bins = np.geomspace(e.min(), e.max(), 20)\n", + "\n", + "# Get the counts in each bin\n", + "counts, _ = np.histogram(e, bins=bins)\n", + "\n", + "# Plot hist and error bands\n", + "ax.stairs(\n", + " counts,\n", + " bins,\n", + ")\n", + "ax.fill_between(\n", + " bins[1:], counts - np.sqrt(counts), counts + np.sqrt(counts), step=\"pre\", alpha=0.5\n", + ")\n", + "\n", + "# Add information and double log\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale(\"log\")\n", + "\n", + "ax.set_xlabel(\"Energy / $\\mathrm{GeV}$\")\n", + "ax.set_ylabel(\"$\\mu^\\pm$ Count per bin\")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "f4bcd26d-35bc-47be-a2c5-2cd39050a9b8", + "metadata": {}, + "source": [ + "Of course, this is not a real energy-distribution, since the simulation is just randomly sampled from a $E^{-1}$ power-law (as specified in the steering-card above). We just see the power-law distribution in the plot. \n", + "To obtain a real simulation, we have to apply weights to the simulation. \n", + "`panama` also provides functionality for that (See later in this notebook). \n", + "\n", + "\n", + "### Exporting the data\n", + "Since `DAT` files are not the most efficient format, and more importantly, is not a standarized self-discribing format, we can also use `pandas` and `panama` to export the CORSIKA7 dataset to a different format:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "230f1a5e-3b3a-4a8a-8e27-52394c39e7aa", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_117990/1262720920.py:2: PerformanceWarning: \n", + "your performance may suffer as PyTables will pickle object types that it cannot\n", + "map directly to c-types [inferred_type->mixed,key->block1_values] [items->Index(['observation_height'], dtype='object')]\n", + "\n", + " run_header.to_hdf(output, \"run_header\")\n" + ] + } + ], + "source": [ + "output = \"corsika_output/dataset.hdf5\"\n", + "run_header.to_hdf(output, \"run_header\")\n", + "event_header.to_hdf(output, \"event_header\")\n", + "particles.to_hdf(output, \"particles\")" + ] + }, + { + "cell_type": "markdown", + "id": "03aabcf0-fa03-4565-9391-3ed7455e0a2d", + "metadata": {}, + "source": [ + "The warning is nothing to worry about, as the run_header is a very small object anyway. It stores the different heights of the observation levels as touples, which must be pickled so saving is less efficient. Pandas warns us about that.\n", + "\n", + "We can now read in the simulation again, which should be faster and also does not require knowledge about the specific corsika DAT format, so it could even be used without `panama` or any CORSIKA7 knowledge at all." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "28b7a767-4c55-4a93-9a70-ad44660d8ada", + "metadata": {}, + "outputs": [], + "source": [ + "run_header = pd.read_hdf(\"corsika_output/dataset.hdf5\", \"run_header\")\n", + "event_header = pd.read_hdf(\"corsika_output/dataset.hdf5\", \"event_header\")\n", + "particles = pd.read_hdf(\"corsika_output/dataset.hdf5\", \"particles\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1aa62cee-cda9-45c6-bb57-03e0849f3860", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(4000, 107)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "event_header.shape" + ] + }, + { + "cell_type": "markdown", + "id": "be6d9c19-a2f3-4295-8131-49ff70ecd6b3", + "metadata": {}, + "source": [ + "Good! That means that we retained all of the 4000 simulated events. In theory, we could delete the `DAT` files now. If disc-space is not a constrain, it can be a good idea to backup the original `DAT` files for debugging purposes. As for example the original rows containing the mother particles are dropped (at least if we read it with the options used here). In general, `panama` reads in the important information, so except in some constructed unlikely edge-cases, it is save to delete them. Let's look at their size for comparison: " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d0387113-da29-4418-9a5b-45cb85b1a48b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "401M\tcorsika_output\n", + "301M\tcorsika_output/dataset.hdf5\n" + ] + } + ], + "source": [ + "!du -h corsika_output\n", + "!du -h corsika_output/*.hdf5" + ] + }, + { + "cell_type": "markdown", + "id": "052d8281-99b7-4be6-b3ee-ceb2db799a58", + "metadata": {}, + "source": [ + "We see that actually, the hdf5 file is 214 MB, whereas the size of all DAT files is lower with only about 100MB. \n", + "What went wrong? To factors: The hdf5 file actually holds more information: The column names and particle masses for example. Also a lot of the information is redundant: For convenience, the mass is given for every particle, although two muons obiously always have the same mass.\n", + "On the other hand, we did not turn on compression when generating the hdf5 file. Let's see how much we can compress it:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cf179f23-cb89-4298-b8c5-6e9cbcf41eae", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_117990/1504898620.py:2: PerformanceWarning: \n", + "your performance may suffer as PyTables will pickle object types that it cannot\n", + "map directly to c-types [inferred_type->mixed,key->block1_values] [items->Index(['observation_height'], dtype='object')]\n", + "\n", + " run_header.to_hdf(output, \"run_header\", complevel=5)\n" + ] + } + ], + "source": [ + "output = \"corsika_output/dataset_compressed.hdf5\"\n", + "run_header.to_hdf(output, \"run_header\", complevel=5)\n", + "event_header.to_hdf(output, \"event_header\", complevel=5)\n", + "particles.to_hdf(output, \"particles\", complevel=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8d9cf732-3173-43fb-8434-808b1f9e784d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "81M\tcorsika_output/dataset_compressed.hdf5\n" + ] + } + ], + "source": [ + "!du -h corsika_output/*compressed.hdf5" + ] + }, + { + "cell_type": "markdown", + "id": "d2d689c0-27f9-4f58-b409-901039c71611", + "metadata": {}, + "source": [ + "This actually compresses the hdf5 files with more information to less space then the DAT files! Obviously, saving now took a much longer time. A smaller compression level (e.g. 5) might be a good compromise.\n", + "\n", + "Reading will also take slightly longer (not as much as writing, though):" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "967a47b8-4681-41bd-98d3-ad075b5ac4ba", + "metadata": {}, + "outputs": [], + "source": [ + "run_header = pd.read_hdf(\"corsika_output/dataset_compressed.hdf5\", \"run_header\")\n", + "event_header = pd.read_hdf(\"corsika_output/dataset_compressed.hdf5\", \"event_header\")\n", + "particles = pd.read_hdf(\"corsika_output/dataset_compressed.hdf5\", \"particles\")" + ] + }, + { + "cell_type": "markdown", + "id": "cfbe5a99-1b6d-4367-a955-08dbfa8f19ad", + "metadata": {}, + "source": [ + "Of course, you can also use other formats to save the simulation, `pandas` is quite versatile in that regard. (You can even consider to export your simulation to excel)\n", + "If you want to be bleeding-edge modern, have a look at `.to_parquet()`.\n", + "\n", + "`panama` provides a command line utility to convert DAT files to `hdf5` files, with `panama hdf5`. The default compression level there is 5." + ] + }, + { + "cell_type": "markdown", + "id": "95b33b78-9a68-43bc-867c-d16c33f9bdeb", + "metadata": {}, + "source": [ + "### Weighting the Simulation\n", + "`panama` provides utilities to weight the simulation, to produce physical spectra.\n", + "For that, we have to assume a flux with which the cosmic rays arrive on top of the atmosphere. These are provided in the `fluxcomp` package (it's automatically installed with `panama`)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "914ac2e4-edc1-46ab-bec4-b3f05bae2ada", + "metadata": {}, + "outputs": [], + "source": [ + "import fluxcomp" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "57dbc3c6-223b-4729-b899-f440b20b0fba", + "metadata": {}, + "outputs": [], + "source": [ + "particles[\"weight_GSF\"] = pn.get_weights(\n", + " run_header,\n", + " event_header,\n", + " particles,\n", + " model=fluxcomp.GlobalSplineFit(),\n", + " proton_only=False, # This controls if for example a helium is treated as 4 protons.\n", + " # This means, that only the proton information of the MC is used (proton_only=True).\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "475f84be-90de-460c-9f93-03041304851d", + "metadata": {}, + "source": [ + "You can even combine multiple-datasets with different energy regions of different runs and correctly weight them with this function. \n", + "The only thing which is currently not possible is to weigh simulations with overlapping energy-regions. The function will throw an error then." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5094c74c-00e5-4f3e-acd0-1f5c8939a8ae", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select all muons and anti-muons and histogram their energy\n", + "sel = particles.query(\"pdgid in (13, -13)\")\n", + "e = sel[\"energy\"]\n", + "\n", + "# Create new plot\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Use logarithmically sized bins\n", + "# Since we only simulated between 1e4 and 1e9 GeV,\n", + "# Only these bounds make sense. (above 1e7, most muons come from 1e9 primaries and above)\n", + "bins = np.geomspace(1e4, 1e7, 20)\n", + "\n", + "# Get the weighted counts (=flux) in each bin\n", + "flux, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"])\n", + "# The error for weighted histograms calculates as follows\n", + "err, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"] ** 2)\n", + "err = np.sqrt(err)\n", + "\n", + "# The differential flux is more informative, so we convert to that\n", + "flux /= np.diff(bins)\n", + "err /= np.diff(bins)\n", + "\n", + "# Plot hist and error bands\n", + "ax.stairs(\n", + " flux,\n", + " bins,\n", + ")\n", + "ax.fill_between(bins[1:], flux - err, flux + err, step=\"pre\", alpha=0.5)\n", + "\n", + "# Add information and double log\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale(\"log\")\n", + "\n", + "ax.set_xlabel(\"Energy / $\\mathrm{GeV}$\")\n", + "ax.set_ylabel(\"Flux $\\Phi_{\\mu^\\pm}\\ /\\ 1/(\\mathrm{m^2 s\\ sr GeV})$\")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "6702ccd8-52a5-4559-b0f3-dd4ae3119007", + "metadata": {}, + "source": [ + "#### Examining the prompt spectrum\n", + "\n", + "We can now also only select prompt particles and plot their spectrum:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b4ff2d68-bed5-4661-9080-5a1fd1cb93c9", + "metadata": {}, + "outputs": [], + "source": [ + "# This key is provided by default under \"is_prompt\", when using \"additional_columns=True\" when reading in from dat\n", + "# pn.prompt also features other definitions of prompt with a similar interace. It is well-documented.\n", + "particles[\"is_prompt_lifetime\"] = pn.prompt.is_prompt_lifetime_limit(particles)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "83728cb1-1d2a-425c-ad1a-186bca2ab7ff", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select all muons and anti-muons and histogram their energy\n", + "sel = particles.query(\"pdgid in (13, -13) and is_prompt_lifetime == True\")\n", + "e = sel[\"energy\"]\n", + "\n", + "# Create new plot\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Use logarithmically sized bins\n", + "# Since we only simulated between 1e4 and 1e9 GeV,\n", + "# Only these bounds make sense. (above 1e7, most muons come from 1e9 primaries and above)\n", + "bins = np.geomspace(1e4, 1e7, 20)\n", + "\n", + "# Get the weighted counts (=flux) in each bin\n", + "flux, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"])\n", + "# The error for weighted histograms calculates as follows\n", + "err, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"] ** 2)\n", + "err = np.sqrt(err)\n", + "\n", + "# The differential flux is more informative, so we convert to that\n", + "flux /= np.diff(bins)\n", + "err /= np.diff(bins)\n", + "\n", + "# Plot hist and error bands\n", + "ax.stairs(\n", + " flux,\n", + " bins,\n", + ")\n", + "ax.fill_between(bins[1:], flux - err, flux + err, step=\"pre\", alpha=0.5)\n", + "\n", + "# Add information and double log\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale(\"log\")\n", + "\n", + "ax.set_xlabel(\"Energy / $\\mathrm{GeV}$\")\n", + "ax.set_ylabel(\"Flux $\\Phi_{\\mu^\\pm}\\ /\\ 1/(\\mathrm{m^2 s\\ sr GeV})$\")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "6ca5241b-f90b-4334-9850-bdac5d0b79f2", + "metadata": {}, + "source": [ + "We see, that the simulation lacks of statistics. At about 100_000 datapoints with a similar setting, the spectra become good." + ] + }, + { + "cell_type": "markdown", + "id": "ec47d55b-2a17-40db-aca9-1cafd6a11e04", + "metadata": {}, + "source": [ + "**That's it!** These was a introduction in all features in `panama`. Each function provides almost always more options, so have a look at the documentation. \n", + "Should you encounter bugs or have suggestions for improvement, please open an [issue](https://github.com/The-Ludwig/PANAMA/issues) or a [pull request](https://github.com/The-Ludwig/PANAMA/pulls) and get in touch." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/plot_spectrum.ipynb b/docs/examples/plot_spectrum.ipynb new file mode 100644 index 0000000..be271d9 --- /dev/null +++ b/docs/examples/plot_spectrum.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "edea2e54-9ced-4b59-8d0d-9007a5171f6b", + "metadata": {}, + "source": [ + "Plotting a Muon Spectrum with `panama`\n", + "======================================\n", + "\n", + "This notebook showcases how to read in a muon spectrum in panama and plot it.\n", + "For that you have to have some CORSIKA7 DAT files, for example use the ones provided in `panama`s test folder." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "79eed08c-340f-478b-9a7d-854d4e21f513", + "metadata": {}, + "outputs": [], + "source": [ + "# These modules will be used\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import panama as pn\n", + "import fluxcomp\n", + "\n", + "# To convert PDG IDs to particle names\n", + "from particle import Particle" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "23a17537-cb5f-46b1-ad3d-58ab31a3e7e9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 900/900.0 [00:00<00:00, 18677.23it/s]\n" + ] + } + ], + "source": [ + "# Load the full dataset\n", + "run_header, event_header, particles = pn.read_DAT(\n", + " glob=\"../../tests/files/DAT*\", mother_columns=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "1cf6f7d9-405d-4b92-8945-f0a97e4bb5a6", + "metadata": {}, + "source": [ + "**Tip**:\n", + "This dataset is very small, but for larger datasets it might be useful to load in the DAT files using `panama` and \n", + "then exporting them to `hdf` using e.g. `particles.to_hdf`, since this format should be faster. You can additionally drop information you don't need.\n", + "To do this from the command line, `panama` provides the command `panama hdf5`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "be93f3ba-8dff-44cf-9cc0-944e56b5c059", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select all muons and anti-muons and histogram their energy\n", + "e = particles.query(\"pdgid in (13, -13)\")[\"energy\"]\n", + "\n", + "# Create new plot\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Use logarithmically sized bins\n", + "bins = np.geomspace(e.min(), e.max(), 20)\n", + "\n", + "# Get the counts in each bin\n", + "counts, _ = np.histogram(e, bins=bins)\n", + "\n", + "# Plot hist and error bands\n", + "ax.stairs(\n", + " counts,\n", + " bins,\n", + ")\n", + "ax.fill_between(\n", + " bins[1:], counts - np.sqrt(counts), counts + np.sqrt(counts), step=\"pre\", alpha=0.5\n", + ")\n", + "\n", + "# Add information and double log\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale(\"log\")\n", + "\n", + "ax.set_xlabel(\"Energy / $\\mathrm{GeV}$\")\n", + "ax.set_ylabel(\"$\\mu^\\pm$ Count per bin\")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "e5896036-e697-428f-8755-5281bf6c0d36", + "metadata": {}, + "source": [ + "This histogram does not yet relate to a flux, as it is only a count and the simulation has to be weighted.\n", + "The falling spectrum with $E^{-1}$ in the plot above indicates the simulation spectral index was $-1$.\n", + "\n", + "So let's add weights to the simulation now!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2ac90477-de94-47fb-9873-39ccf44a30fa", + "metadata": {}, + "outputs": [], + "source": [ + "particles[\"weight_GSF\"] = pn.get_weights(\n", + " run_header,\n", + " event_header,\n", + " particles,\n", + " model=fluxcomp.GlobalSplineFit(),\n", + " proton_only=True,\n", + ")\n", + "particles[\"weight_GST\"] = pn.get_weights(\n", + " run_header, event_header, particles, model=fluxcomp.GlobalFitGST(), proton_only=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d51acb13-b162-4510-b95b-5739903a1dab", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAG+CAYAAACpurGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5+UlEQVR4nO3df1yV9f3/8efhNxGoiJCioGU6FX8CmiYqK1DMH2k//GylWFg55qcUnfPHvjVdyqZOXR+nqVuaWzWtltn0E9JnmkwsFXH5I0sXCeKv+QsUERDO948t1glE5JzrOpzj4367cXPnuq7zer/OvG747H29z3VZrFarVQAAADCUh7MbAAAAuB0QugAAAExA6AIAADABoQsAAMAEhC4AAAATELoAAABMQOgCAAAwAaELAADABIQuAAAAExC6AAAATEDoAgAAMAGh6yby8vIUHx+vzp07q2vXriopKXF2SwAAwAVZeOB13QYOHKiXX35ZcXFxunDhgoKCguTl5eXstgAAgIshPdTh0KFD8vb2VlxcnCQpODjYyR0BAABX5dKha8eOHVq4cKFycnJ06tQpvffee3r44Ydtjlm+fLkWLlyoU6dOqUuXLlq6dGl1iLqZo0eP6s4779SIESN04sQJPfroo5o1a1a9+6uqqtLJkycVGBgoi8VyKx8NAAA4idVq1eXLl9WqVSt5eDhuJZZLh66SkhJ1795dTz31lB555JEa+9evX6/Jkydr+fLluv/++7Vy5UolJSXp8OHDioiIkCRFR0errKysxnu3bt2qiooKZWVlaf/+/QoNDdWQIUMUGxurhISEWvspKyuzqVVYWKjOnTs76NMCAAAzFRQUqHXr1g6r5zZruiwWS42Zrj59+qhXr15asWJF9bZOnTrp4YcfVnp6+k1r7tq1S3PmzNGHH34oSVq4cKEk6Sc/+Umtx//85z/XnDlzamwvKChQUFDQrXwcAADgJMXFxWrTpo0uXbqkJk2aOKyuS8901aW8vFw5OTmaMWOGzfbExERlZ2fXq0ZsbKzOnDmjixcvqkmTJtqxY4eee+65Gx4/c+ZMpaWlVb/+5i8tKCiI0AUAgItx9NIgtw1d586dU2VlpcLCwmy2h4WF6fTp0/Wq4eXlpfnz52vAgAGyWq1KTEzUsGHDbni8r6+vfH197eobAAC4J7cNXd/4bkq1Wq23lFyTkpKUlJTk6LYAAMBtxm1vjhoSEiJPT88as1pnz56tMfsFAABgNLcNXT4+PoqOjlZmZqbN9szMTPXr189JXQEAgNuVS19evHLlio4dO1b9Oi8vT/v371dwcLAiIiKUlpamsWPHKiYmRn379tWqVauUn5+viRMnOrFrAABwO3Lp0LV3717Fx8dXv/7mm4PJyclau3atxowZo/Pnz2vu3Lk6deqUoqKitGXLFkVGRjqrZQAAcJtym/t0NUbFxcVq0qSJioqKuGUEAAAuwqh/v912TRcAAEBjQugCAAAwAaELAADABIQuAAAAExC6AAAATEDoAgAAMAGhCwAAwAQufXNUGGdJ5peG1p+S0MHQ+gAANDbMdAEAAJiA0AUAAGACQhcAAIAJWNPlogovlepiSblh9S9fq1Cgn7dh9QEAuN0QulxQ4aVSPfjrj1VaUWnYGF4eFg3r1lL+Pp6G1C+8VKrwpv6G1AYAoDEidLmgiyXlKq2o1NIxPdQ+9E6H1z9fUq6UtXu0cf9Jh9f+xsbck/po6kCCFwDgtkHocmHtQ+9UVHgTQ2qP6xtp2EzahZJyZRw6o4sl5YQuAMBtg9CFWgX6ebOmCwAAB+LbiwAAACYgdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAmIHQBAACYgFtGwC0tyfzSsNpTEjoYVhsA4L4IXaiVkcHiYGGR3tpdYFh9AAAaIy4vAgAAmIDQBQAAYAJCFwAAgAkIXQAAACYgdAEAAJiAby/CLV2+VqHSikpDahdeKlV4U39DagMA3BehC26n8FKp1u06rutVVkPqb8w9qY+mDiR4AQBuCaELbudiSbmuV1k1uEuYggN8HFr7Qkm5Mg6d0cWSckIXAOCWELrgtoIDfBQa6OfsNgAAkMRCegAAAFMQugAAAExA6AIAADABa7rgNG98etyQNVdnL19zeE0AAOzFTBcAAIAJCF0AAAAmIHQBAACYgNAFAABgAhbSw2kulJS7VF0AAOxB6ILpmgX4yMvDooxDZwwbw8vDIn9vT8PqAwBwqwhdMF14U3+N6xup0opKw8bw9/ZUoJ+3YfUBALhVhC44RaCfN6EIAHBbYSE9AACACQhdAAAAJiB0AQAAmIDQBQAAYAJCFwAAgAkIXTexZMkSdenSRZ07d9bzzz8vq9Xq7JYAAIALInTV4Z///KeWLVumnJwcHThwQDk5Ofrkk0+c3RYAAHBB3KfrJq5fv65r165JkioqKhQaGurkjtzDlIQOzm6hQQ4WFumt3QXObgMA4IJceqZrx44dGj58uFq1aiWLxaKNGzfWOGb58uVq166d/Pz8FB0draysrHrXb9GihaZNm6aIiAi1atVKDz74oO655x4HfgIAAHC7cOmZrpKSEnXv3l1PPfWUHnnkkRr7169fr8mTJ2v58uW6//77tXLlSiUlJenw4cOKiIiQJEVHR6usrKzGe7du3Sp/f3/95S9/0ddffy1/f38lJSVpx44dGjBgQK39lJWV2dQqLi520CcFAACuzqVDV1JSkpKSkm64f/HixUpJSdGECRMkSUuXLlVGRoZWrFih9PR0SVJOTs4N3//222+rffv2Cg4OliQ99NBD+uSTT24YutLT0zVnzpyGfhwAAODGXPryYl3Ky8uVk5OjxMREm+2JiYnKzs6uV402bdooOztb165dU2VlpbZv366OHTve8PiZM2eqqKio+qeggLU/AADgX1x6pqsu586dU2VlpcLCwmy2h4WF6fTp0/Wqcd9992no0KHq2bOnPDw89MADD2jEiBE3PN7X11e+vr529Q0AANyT24aub1gsFpvXVqu1xra6zJs3T/PmzXN0WwAA4DbjtpcXQ0JC5OnpWWNW6+zZszVmvwAAAIzmtqHLx8dH0dHRyszMtNmemZmpfv36OakrAABwu3Lpy4tXrlzRsWPHql/n5eVp//79Cg4OVkREhNLS0jR27FjFxMSob9++WrVqlfLz8zVx4kQndg0AAG5HLh269u7dq/j4+OrXaWlpkqTk5GStXbtWY8aM0fnz5zV37lydOnVKUVFR2rJliyIjI53VMgAAuE25dOgaNGjQTR9AnZqaqtTUVJM6AgAAqJ3brukCAABoTAhdAAAAJiB0AQAAmIDQBQAAYAJCFwAAgAkIXQAAACYgdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAmIHQBAACYgNAFAABgAkIXAACACbyc3QAAW0syvzS0/pSEDobWBwDUjpkuAAAAExC6AAAATEDoAgAAMAGhCwAAwAQspAcamcvXKlRaUWlY/cJLpQpv6m9YfQBA7QhdQAO88elxhQb6Obzu5WsVWrfruK5XWR1e+xsbc0/qo6kDCV4AYDJCF9CIlFZU6nqVVYO7hCk4wMfh9S+UlCvj0BldLCkndAGAyQhdQCMUHOBjyEwaAMB5WEgPAABgAkIXAACACbi8CDTAhZJyl6oLAHA+QhdwC5oF+MjLw6KMQ2cMG8PLwyJ/b0/D6gMAnIPQBdyC8Kb+Gtc30tD7aPl7eyrQz9uw+gAA53BI6KqoqNDp06d19epVtWjRQsHBwY4oCzRKgX7ehCIAwC1r8EL6K1euaOXKlRo0aJCaNGmitm3bqnPnzmrRooUiIyP1zDPPaM+ePY7sFQAAwGU1KHQtWbJEbdu21erVq/X9739ff/7zn7V//3598cUX2rVrl1566SVdv35dCQkJGjJkiI4ePerovgEAAFxKgy4vZmdna9u2beratWut+3v37q2nn35ar776qn7/+9/r448/1r333mtXowAAAK6sQaHr7bffrtdxvr6+Sk1NbcgQwG1rSkIHw2ofLCzSW7sLDKsPALixBq/p2r9/vwPbAAAAcG8NDl29evVSdHS0VqxYoaKiIkf2BAAA4HYaHLp27typXr16acaMGWrZsqWefPJJbdu2zZG9AQAAuI0Gh66+fftq9erVOn36tFasWKETJ07owQcf1D333KN58+bpxIkTjuwTAADApdn9wGt/f38lJydr+/bt+vLLL/WDH/xAK1euVLt27TR06FBH9AgAAODy7A5d33bPPfdoxowZmj17toKCgpSRkeHI8gAAAC7LYc9e/Pjjj/Xaa6/p3Xfflaenpx5//HGlpKQ4qjzQaBh5SwcAgPuyK3QVFBRo7dq1Wrt2rfLy8tSvXz/9z//8jx5//HEFBAQ4qkcAAACX1+DQlZCQoG3btqlFixYaN26cnn76aXXs2NGRvQEAALiNBocuf39/vfvuuxo2bJg8PT0d2RMAAIDbafBC+k2bNmnkyJHy9PRUVlaWnnzySfXt21eFhYWSpD/84Q/629/+5rBGAQAAXJnd31589913NXjwYPn7+ys3N1dlZWWSpMuXL2v+/Pl2NwgAAOAO7A5dL7/8sl599VWtXr1a3t7e1dv79eunffv22VseAADALdgdur744gsNGDCgxvagoCBdunTJ3vIAAABuwe7Q1bJlSx07dqzG9r/97W+6++677S0PAADgFuwOXc8995xeeOEFffrpp7JYLDp58qTeeOMNTZs2TampqY7oEQAAwOXZfUf66dOnq6ioSPHx8bp27ZoGDBggX19fTZs2TZMmTXJEjwAAAC7PIY8BmjdvnmbPnq3Dhw+rqqpKnTt31p133umI0gAAAG7BYQ+8vuOOOxQTE6PevXu7ZOAaNWqUmjVrpkcffbTGvr/85S/q2LGj7r33Xv3ud79zQncAAMDVNXimq7S0VP/3f/+nYcOGSZJmzpxZfY8uSfL09NQvfvEL+fn52d+lCZ5//nk9/fTTev311222X79+XWlpadq2bZuCgoLUq1cvjR49WsHBwU7qFAAAuKIGz3StW7dOK1eurH69bNkyZWdnKzc3V7m5ufrjH/+oFStWOKRJM8THxyswMLDG9t27d6tLly4KDw9XYGCghg4dqoyMDCd0CAAAXFmDQ9cbb7yhp59+2mbbm2++qW3btmnbtm1auHChNmzYYHeDkrRjxw4NHz5crVq1ksVi0caNG2scs3z5crVr105+fn6Kjo5WVlaWQ8Y+efKkwsPDq1+3bt26+lFHAAAA9dXg0PXll1+qQ4cO1a/9/Pzk4fGfcr1799bhw4ft6+7fSkpK1L17dy1btqzW/evXr9fkyZM1e/Zs5ebmKi4uTklJScrPz68+Jjo6WlFRUTV+Tp48WefYVqu1xjaLxVLrsWVlZSouLrb5AQAAkOxY01VUVCQvr/+8/Z///KfN/qqqKps1XvZISkpSUlLSDfcvXrxYKSkpmjBhgiRp6dKlysjI0IoVK5Seni5JysnJadDY4eHhNjNbJ06cUJ8+fWo9Nj09XXPmzGnQOAAAwL01eKardevWOnjw4A33f/bZZ2rdunVDy9dbeXm5cnJylJiYaLM9MTFR2dnZdtfv3bu3Dh48qMLCQl2+fFlbtmzR4MGDaz125syZKioqqv4pKCiwe3wAAOAeGjzTNXToUL344ot66KGHanxDsbS0VHPmzNFDDz1kd4M3c+7cOVVWViosLMxme1hYmE6fPl3vOoMHD9a+fftUUlKi1q1b67333lNsbKy8vLz061//WvHx8aqqqtL06dPVvHnzWmv4+vrK19fXrs8DAADcU4ND16xZs7RhwwZ17NhRkyZNUocOHWSxWHTkyBEtW7ZM169f16xZsxzZa52+u87KarXecO1Vber6RuKIESM0YsSIBvcGAADQ4NAVFham7Oxs/ehHP9KMGTOqF5xbLBYlJCRo+fLlNWafjBASEiJPT88as1pnz541ZXwAAID6sOsxQO3atdOHH36oCxcu6NixY5Kk9u3bm3rjUB8fH0VHRyszM1OjRo2q3p6ZmamRI0ea1gcAAEBd7ApdFRUVSkxM1MqVK9W7d29H9VTDlStXqkOdJOXl5Wn//v0KDg5WRESE0tLSNHbsWMXExKhv375atWqV8vPzNXHiRMN6AgAAuBV2hS5vb28dPHjwltZONcTevXsVHx9f/TotLU2SlJycrLVr12rMmDE6f/685s6dq1OnTikqKkpbtmxRZGSkoX0BAADUl12hS5LGjRun3//+9/rlL3/piH5qNWjQoFpvUvptqampSk1NNawHAAAAe9gdusrLy/W73/1OmZmZiomJUUBAgM3+xYsX2zsEAACAy7M7dB08eFC9evWS9K9HA32b0ZcdAQAAXIXdoWvbtm2O6AMAAMCtNfgxQN8oLS3V1atXq18fP35cS5cu1datW+0tDQAA4DbsDl0jR47UunXrJEmXLl1S79699etf/1ojR47UihUr7G4QAADAHdgduvbt26e4uDhJ0jvvvKO77rpLx48f17p16/TKK6/Y3SAAAIA7sDt0Xb16VYGBgZKkrVu3avTo0fLw8NB9992n48eP290gAACAO7A7dLVv314bN25UQUGBMjIylJiYKOlfzz4MCgqyu0EAAAB3YHfoevHFFzVt2jS1bdtWffr0Ud++fSX9a9arZ8+edjcIAADgDuy+ZcSjjz6q/v3769SpU+revXv19gceeMDmAdQAAAC3M7tDlyTddddduuuuu2y2GfkAbAAAAFdj9+VFAAAA3ByhCwAAwASELgAAABMQugAAAEzAsxcBAABMYPe3F0eOHKnRo0dr4sSJunTpkvr06SNvb2+dO3dOixcv1o9+9CNH9AkAWpL5paH1pyR0MLQ+gNubw5+9GBYWxrMXAQAAvoNnLwIAAJiAZy8CAACYwO41XS+++KJ++MMfasqUKXrggQd49iJwmzN63RUAuCqevQgAAGCCWw5dpaWlunDhgsLDw6u33XXXXTp//rw8PP5ztZJnLwIAAPzHLa3peuedd9ShQwcNHTpU3bp106efflq9b+zYsQ5vDgAAwF3c0kzXyy+/rH379qlFixbau3evkpOTNXv2bP3whz+U1Wo1qkcAkCRdvlah0opKw+oXXipVeFN/w+oDuL3dUuiqqKhQixYtJEkxMTHasWOHRo8erWPHjslisRjSIABI/wpc63Yd1/Uq4/4Db2PuSX00dSDBC4Ahbil0hYaG6rPPPlO3bt0kSc2bN1dmZqaSk5P12WefGdIgAEhSaUWlrldZNbhLmIIDfBxe/0JJuTIOndHFknJCFwBD3FLo+sMf/iAvL9u3+Pj46K233tKkSZMc2hgA12TUJcALJeWSpOAAH4UG+jm8PgAY7ZZCV+vWrW+47/7777e7GQCurfBSqaGXAL08LPL39jSkNgAYze77dEnStWvX9Nlnn+ns2bOqqqqy2TdixAhHDAHABVwsKTf0EqC/t6cC/bwdXhcAzGB36Prwww81btw4nTt3rsY+i8WiykrjvmkEoHHiEiAA1GT3sxcnTZqkxx57TKdOnVJVVZXND4ELAADgX+wOXWfPnlVaWprCwsIc0Q8AAIBbsjt0Pfroo9q+fbsDWgEAAHBfdq/pWrZsmR577DFlZWWpa9eu8va2XeT6/PPP2zsEAACAy7M7dL355pvKyMiQv7+/tm/fbnNneovFQugCAACQA0LXz372M82dO1czZsyQh4fdVysBAADckt2hq7y8XGPGjCFwAS7kjU+PG3JLh7OXrzm8JgC4C7uTUnJystavX++IXgAAANyW3TNdlZWVWrBggTIyMtStW7caC+kXL15s7xAAAAAuz+7QdeDAAfXs2VOSdPDgQZt9315UD6Dx+Obh0a5SFwDcgd2ha9u2bY7oA4AJmgX4yMvDooxDZwwbg4dSA0DtGhS68vPzFRERUe/jCwsLFR4e3pChADhQeFN/jesbqdIK4x7RxUOpAaB2DQpdsbGxGjFihJ555hn17t271mOKioq0YcMG/eY3v9Fzzz2n//7v/7arUQCOEejnTSgCACdoUOj6/PPPNX/+fA0ZMkTe3t6KiYlRq1at5Ofnp4sXL+rw4cM6dOiQYmJitHDhQiUlJTm6bwAAAJfSoNAVHBysRYsW6eWXX9aWLVuUlZWlr7/+WqWlpQoJCdETTzyhwYMHKyoqytH9AmjkpiR0MKz2kswvDasNAEazayG9n5+fRo8erdGjRzuqHwAAALfU4NA1a9YsPfzwwzdc0wWgcTJyJgoAcGMNviP9qVOnNGzYMLVs2VLPPvusNm/erLKyMkf2BgAA4DYaHLrWrFmjM2fOaMOGDWratKmmTp2qkJAQjR49WmvXrtW5c+cc2ScAAIBLs+vZixaLRXFxcVqwYIGOHDmi3bt367777tPq1asVHh6uAQMGaNGiRSosLHRUv4YZNWqUmjVrpkcffdRme0FBgQYNGqTOnTurW7duevvtt53UIQAAcGV2P/D62zp16qTp06dr586dOnHihJKTk5WVlaW33nrLkcMY4vnnn9e6detqbPfy8tLSpUt1+PBhffTRR5oyZYpKSkqc0CEAAHBldj8G6EZatGihlJQUpaSkGDWEQ8XHx2v79u01trds2VItW7aUJIWGhio4OFgXLlxQQECAyR0CAABX5tCZrm8rKCjQ008/7ZBaO3bs0PDhw9WqVStZLBZt3LixxjHLly9Xu3bt5Ofnp+joaGVlZTlk7G/bu3evqqqq1KZNG4fXBgAA7s2w0HXhwgW9/vrrDqlVUlKi7t27a9myZbXuX79+vSZPnqzZs2crNzdXcXFxSkpKUn5+fvUx0dHRioqKqvFz8uTJevVw/vx5jRs3TqtWrbrhMWVlZSouLrb5AQAAkOy4vLhp06Y693/11VcNLV1DUlJSnY8SWrx4sVJSUjRhwgRJ0tKlS5WRkaEVK1YoPT1dkpSTk9Pg8cvKyjRq1CjNnDlT/fr1u+Fx6enpmjNnToPHAQAA7qvBoevhhx+WxWKR1Wq94TEWi6Wh5eutvLxcOTk5mjFjhs32xMREZWdn213farVq/Pjx+v73v6+xY8fWeezMmTOVlpZW/bq4uJhLkQAAQJIdlxdbtmypd999V1VVVbX+7Nu3z5F93tC5c+dUWVmpsLAwm+1hYWE6ffp0vesMHjxYjz32mLZs2aLWrVtrz549kqSdO3dq/fr12rhxo3r06KEePXrowIEDtdbw9fVVUFCQzQ8AAIBkx0xXdHS09u3bp4cffrjW/TebBXO0786qWa3WW5ppy8jIqHV7//79VVVVZVdvAAAADQ5dP/nJT+q8X1X79u21bdu2hpavt5CQEHl6etaY1Tp79myN2S8AAABnafDlxbi4OA0ZMuSG+wMCAjRw4MCGlq83Hx8fRUdHKzMz02Z7ZmZmnYveAQAAzGTYzVEd6cqVKzp27Fj167y8PO3fv1/BwcGKiIhQWlqaxo4dq5iYGPXt21erVq1Sfn6+Jk6c6MSuAQAA/sMlQtfevXsVHx9f/fqbbwgmJydr7dq1GjNmjM6fP6+5c+fq1KlTioqK0pYtWxQZGemslgEAAGy4ROgaNGjQTRflp6amKjU11aSOAAAAbo1LhC4AkKQpCR0Mq32wsEhv7S4wrD4ANHgh/axZs7R7925H9gIAAOC2Ghy6Tp06pWHDhqlly5Z69tlntXnzZpWVlTmyNwAAALfR4NC1Zs0anTlzRhs2bFDTpk01depUhYSEaPTo0Vq7dq3OnTvnyD4BAABcWoNDl/Svu8DHxcVpwYIFOnLkiHbv3q377rtPq1evVnh4uAYMGKBFixapsLDQUf0CAAC4JLtC13d16tRJ06dP186dO3XixAklJycrKytLb731liOHAQAAcDmGfXuxRYsWSklJUUpKilFDAAAAuAyHznQBAACgdoQuAAAAExC6AAAATEDoAgAAMAGPAQKAb3nj0+MKDfQzpLaRjzEC0Pgx0wUAAGACh4euF154weZPAAAAOPDyYllZmU6fPq0LFy4oPz9f5eXljioNAADg8hw203X+/Hlt375dJ0+e1LZt22SxWBxVGgAAwOU5bKarVatWSk5O1ieffFL9JwC4mgslxs3SF14qVXhTf8PqG2lJ5peG1udLBrgdOPzbiz/96U9t/gQAV9AswEdeHhZlHDpj2Bgbc0/qo6kDXTZ4AbCPw0NX27Ztbf4EAFcQ3tRf4/pGqrSi0pD6F0rKlXHojC6WlBO6gNsU9+kCgH8L9PNWoJ+3s9sA4KYMuU/Xf/3Xf2nevHl6//339Y9//EOStGHDBiOGAgAAcAmGhK60tDS1bNlS27dvV0pKioKCgjR79mwjhgIAAHAJhlxe7N27t3r37l39+pNPPtFbb71lxFAAAAAuwZCZrrNnz9q8vu+++/TRRx8ZMRQAAIBLMGSma9iwYTp37pzat2+vrl27qrS0VD179lR5ebl8fHyMGBIAYKDL1yoM+2an5Nr3MAPqy5DQtXv3blmtVh07dkyfffaZDhw4oNOnT6tbt27y9vbWgQMHjBgWAGCAwkulWrfruK5XWQ0bg3uY4XbgsNB16dIlWa1WNWvWTJJksVh077336t5779UjjzxSfdzVq1cdNSQAOJSRd0U/WFikt3YXGFbfSBdLynW9yqrBXcIUHOD4qxXcwwy3C7tD165du5SamqrPPvtMkhQVFaUVK1aoX79+tR5/xx132DskAMAJggN8FBro5+w2AJdl10L648ePKyEhQV5eXkpPT9cvf/lL+fr6KiEhQXl5eY7qEQAAwOXZNdM1f/589evXT//7v/8rT09PSdLUqVP10EMPad68efrd737nkCYBAABcXYNnuvLz87V9+3aNGTNGhYWFys/PV35+vk6cOKExY8Zo27ZtKihwzfULAAAAjtbgma62bdvKYrHo2WefrXW/1WpV27ZtVVlp3FeMAQAAXEWDQ9e+ffs0atQoTZs2Tf3797fZl52drV/96ld6//337W4QAADAHTQ4dPXo0UNxcXHavn27fvzjH9vsS09P14ABA9S9e3e7GwQAAHAHdi2k/+lPf6qePXtq5MiRevLJJ2WxWPTGG29o8+bNys3NdVSPAAAALs+u0NWlSxf96U9/0sSJE/XBBx9Ikpo3b6433nhDXbp0cUiDAAAA7sDum6OOHj1aw4cP14EDB2S1Wqsf9QMAAID/cMhjgLy9vdWrVy9HlAIAAHBLdt2RHgAAAPVD6AIAADCBQy4vAgBwu1qS+aWh9ackdDC0PszDTBcAAIAJ7A5dH3300Q33rVy50t7yAAAAbsHu0PXQQw9p6tSpKi8vr972z3/+U8OHD9fMmTPtLQ8AAOAW7A5dO3bs0AcffKDY2FgdOnRImzdvVlRUlK5cuaK///3vjugRAADA5dkduvr06aPc3Fx169ZN0dHRGjVqlKZOnaq//vWvatOmjSN6BAAAcHkOWUj/xRdfaM+ePWrdurW8vLx05MgRXb161RGlAQAA3ILdt4z45S9/qZdeeknPPvusFi5cqH/84x968skn1a1bN/3xj39U3759HdEnALiFNz49rtBAP4fX5bYCQONnd+j6zW9+o40bNyopKUnSvx6CvXv3bs2aNUuDBg1SWVmZ3U0CANBYXb5WodKKSsPqF14qVXhTf8Pqwzx2h64DBw4oJCTEZpu3t7cWLlyoYcOG2VseAIBGq/BSqdbtOq7rVVbDxtiYe1IfTR1I8HIDdoeu7waubxs4cKC95QEAaLQulpTrepVVg7uEKTjAx+H1L5SUK+PQGV0sKSd0uQG7Q9fcuXPr3P/iiy/aO4ThRo0ape3bt+uBBx7QO++8U2P/1atX1alTJz322GNatGiREzoE4C4ulJTf/KAG4BKUcwUH+BiyVg/uxe7Q9d5779m8rqioUF5enry8vHTPPfe4ROh6/vnn9fTTT+v111+vdf+8efPUp08fk7sC4E6aBfjIy8OijENnDKnPJSig8bM7dOXm5tbYVlxcrPHjx2vUqFH2ljdFfHy8tm/fXuu+o0eP6siRIxo+fLgOHjxobmMA3EZ4U3+N6xtpyIJrLkEBrsGQB14HBQVp7ty5+n//7//ZXWvHjh0aPny4WrVqJYvFoo0bN9Y4Zvny5WrXrp38/PwUHR2trKwsu8f9xrRp05Senu6wegBuX4F+3goN9HP4jxFriQA4niGhS5IuXbqkoqIiu+uUlJSoe/fuWrZsWa37169fr8mTJ2v27NnKzc1VXFyckpKSlJ+fX31MdHS0oqKiavycPHmyzrHff/99dejQQR061O/+N2VlZSouLrb5AQAAkBxwefGVV16xeW21WnXq1Cn94Q9/0JAhQ+wtr6SkpOp7gNVm8eLFSklJ0YQJEyRJS5cuVUZGhlasWFE9Q5WTk9OgsT/55BP96U9/0ttvv60rV66ooqJCQUFBN1ynlp6erjlz5jRoLAAA4N7sDl1Lliyxee3h4aEWLVooOTlZM2fOtLd8ncrLy5WTk6MZM2bYbE9MTFR2drbd9dPT06uD29q1a3Xw4ME6vxgwc+ZMpaWlVb8uLi7m+ZMAAECSA0JXXl6eI/pokHPnzqmyslJhYWE228PCwnT69Ol61xk8eLD27dunkpIStW7dWu+9955iY2NvuR9fX1/5+vre8vsAAID7szt0NQYWi8XmtdVqrbGtLhkZGTc9Zvz48bfaFgAAQLUGha5vX0K7mcWLFzdkiHoJCQmRp6dnjVmts2fP1pj9AgBnM+qh1AcLi/TW7gJDagNwnAaFrtruzVWbW5ltaggfHx9FR0crMzPT5p5gmZmZGjlypKFjAwAA3IoGha5t27bpq6++Utu2beXhYdhdJyRJV65c0bFjx6pf5+Xlaf/+/QoODlZERITS0tI0duxYxcTEqG/fvlq1apXy8/M1ceJEQ/sCgNvNE30iFRXexOF1manD7aLBa7ruvfdenTp1SqGhoZKkMWPG6JVXXnH4Zb29e/cqPj6++vU3lzaTk5O1du1ajRkzRufPn9fcuXN16tQpRUVFacuWLYqMjHRoHwAAAPZocOiyWq02r7ds2WLIndsHDRpUY6zvSk1NVWpqqsPHBgAAcBRjrw0CAABAkh2hy2Kx1Fgob/TCeQAAAFdl1+XF8ePHV98M9Nq1a5o4caICAgJsjvvzn/9sX4cAAABuoMGhKzk52eb1k08+aXczAICGe+PT4woN9HN43bOXrzm8JnA7anDoWrNmjSP7AAAAcGsspAcAADABoQsAAMAEbvHAawCAdKGk3KXqArcbQhcAuLhmAT7y8rAo49AZw8bw9/ZUswAfw+oDtwNCFwC4uPCm/hrXN1KlFZWGjTHp+/cqvKm/YfWB2wGhCwDcQKCftwL9vA2rT+AC7MdCegAAABMQugAAAExA6AIAADABoQsAAMAELKQHADcwJaGDs1sAcBPMdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAmIHQBAACYgNAFAABgAkIXAACACQhdAAAAJiB0AQAAmIDQBQAAYAJCFwAAgAkIXQAAACYgdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAm8HJ2AwAAoG5vfHpcoYF+htSektDBkLqoiZkuAAAAExC6AAAATEDoAgAAMAFrugAAgGGWZH5pWG1XW4/GTBcAAIAJmOkCADQKfEMP7o6ZLgAAABMQugAAAEzA5UUAABq5CyXlhtUuvFSq8Kb+htXHfxC6AABopPy9PeXlYVHGoTOGjbEx96Q+mjqQ4GUCQhcAAI1UoJ+3xvWNVGlFpSH1L5SUK+PQGV0sKSd0mYDQBQBoFLiEVrtAP28F+nk7u40Gu3ytwrDQ6Gp/r4QuAIBTNQvw4RKamyq8VKp1u47repXVkPqu9vdK6AIAOFV4U38uobmpiyXlul5l1eAuYQoO8HFobVf8eyV0AQCcztUvoaFuwQE+ht341pVwny4AAAATELoAAABMQOj6t1GjRqlZs2Z69NFHa+zLy8tTfHy8OnfurK5du6qkpMQJHQIAAFdG6Pq3559/XuvWrat13/jx4zV37lwdPnxYH3/8sXx9fU3uDgAAuDpC17/Fx8crMDCwxvZDhw7J29tbcXFxkqTg4GB5efH9AwAAcGtcInTt2LFDw4cPV6tWrWSxWLRx48Yaxyxfvlzt2rWTn5+foqOjlZWV5ZCxjx49qjvvvFMjRoxQr169NH/+fIfUBQAAtxeXmLIpKSlR9+7d9dRTT+mRRx6psX/9+vWaPHmyli9frvvvv18rV65UUlKSDh8+rIiICElSdHS0ysrKarx369atatWq1Q3HrqioUFZWlvbv36/Q0FANGTJEsbGxSkhIqHFsWVmZzRjFxcUN+bgAABfzRJ9IRYU3MaT2kswvDakL87lE6EpKSlJSUtIN9y9evFgpKSmaMGGCJGnp0qXKyMjQihUrlJ6eLknKyclp0NitW7dWbGys2rRpI0kaOnSo9u/fX2voSk9P15w5cxo0DgAAcG8ucXmxLuXl5crJyVFiYqLN9sTERGVnZ9tdPzY2VmfOnNHFixdVVVWlHTt2qFOnTrUeO3PmTBUVFVX/FBQU2D0+AABwDy4x01WXc+fOqbKyUmFhYTbbw8LCdPr06XrXGTx4sPbt26eSkhK1bt1a7733nmJjY+Xl5aX58+drwIABslqtSkxM1LBhw2qt4evryzcbAQBArVw+dH3DYrHYvLZarTW21SUjI+OG+252eRMAAOBmXD50hYSEyNPTs8as1tmzZ2vMfgEAGqcpCR0Mq32wsEhv7Wa5B5zP5dd0+fj4KDo6WpmZmTbbMzMz1a9fPyd1BQAAYMslZrquXLmiY8eOVb/Oy8vT/v37FRwcrIiICKWlpWns2LGKiYlR3759tWrVKuXn52vixIlO7BoA0Ji88elxhQb6ObTm2cvXHFoP7s0lQtfevXsVHx9f/TotLU2SlJycrLVr12rMmDE6f/685s6dq1OnTikqKkpbtmxRZGSks1oGAACw4RKha9CgQbJarXUek5qaqtTUVJM6AgAAuDUuv6YLAADAFRC6AAAATOASlxcBALDXhZJyl6gJ90XoAgC4tWYBPvLysCjj0BlD6vt7e6pZgI8hteFeCF0AALcW3tRf4/pGqrSi0pD6k75/r8Kb+htSG+6F0AUAcHuBft4K9PM2pDaB6+ae6BOpqPAmDq3pik8aYCE9AACACQhdAAAAJiB0AQAAmIDQBQAAYAJCFwAAgAkIXQAAACYgdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAm4DFAAAC3NyWhg7NbAJjpAgAAMAOhCwAAwASELgAAABMQugAAAEzAQnoAABoxI78EcLCwSG/tLjCsPmwx0wUAAGACQhcAAIAJCF0AAAAmIHQBAACYgNAFAABgAkIXAACACQhdAAAAJiB0AQAAmIDQBQAAYAJCFwAAgAkIXQAAACYgdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAm8HJ2A+7MarVKkoqLix1a98rlYlWVXdWVy8UqLrY4tDYA4PZh9L8nRtY3svY3/25/8++4o1isjq6IaidOnFCbNm2c3QYAAGiAgoICtW7d2mH1CF0Gqqqq0smTJxUYGCiLpWYKj42N1Z49e274/hvtLy4uVps2bVRQUKCgoCCH9myWm332xjyevbVu9f23cnx9juW8M+e8c/RY9tRryHvr+x4jzznJ9c87V/5dZ289V/9dd/jwYXXs2FEeHo5bicXlRQN5eHjUmZA9PT3r/CVys/1BQUEu+UtIuvlna8zj2VvrVt9/K8fX51jOO3N6d/RY9tRryHvr+x4zzjnJdc87V/5dZ289V/9dFx4e7tDAJbGQ3ql+/OMf27XflZn92Rw5nr21bvX9t3J8fY7lvHPNseyp15D31vc9nHN1c+XfdfbW43ddTVxedEHFxcVq0qSJioqKXPK//OCaOO/gDJx3MJuR5xwzXS7I19dXL730knx9fZ3dCm4jnHdwBs47mM3Ic46ZLgAAABMw0wUAAGACQhcAAIAJCF0AAAAmIHQBAACYgNAFAABgAkKXm7l8+bJiY2PVo0cPde3aVatXr3Z2S7hNXL16VZGRkZo2bZqzW8FtwsvLSz169FCPHj00YcIEZ7eD20ReXp7i4+PVuXNnde3aVSUlJfV+L7eMcDOVlZUqKyvTHXfcoatXryoqKkp79uxR8+bNnd0a3Nzs2bN19OhRRUREaNGiRc5uB7eBkJAQnTt3ztlt4DYzcOBAvfzyy4qLi9OFCxcUFBQkL6/6PVWRmS434+npqTvuuEOSdO3aNVVWVopcDaMdPXpUR44c0dChQ53dCgAY5tChQ/L29lZcXJwkKTg4uN6BSyJ0NTo7duzQ8OHD1apVK1ksFm3cuLHGMcuXL1e7du3k5+en6OhoZWVl2ey/dOmSunfvrtatW2v69OkKCQkxqXu4Ikecc9OmTVN6erpJHcMdOOK8Ky4uVnR0tPr376+PP/7YpM7hyuw9744ePao777xTI0aMUK9evTR//vxbGp/Q1ciUlJSoe/fuWrZsWa37169fr8mTJ2v27NnKzc1VXFyckpKSlJ+fX31M06ZN9fe//115eXl68803debMGbPahwuy95x7//331aFDB3Xo0MHMtuHiHPG77uuvv1ZOTo5effVVjRs3TsXFxWa1Dxdl73lXUVGhrKws/fa3v9WuXbuUmZmpzMzM+jdgRaMlyfree+/ZbOvdu7d14sSJNtu+973vWWfMmFFrjYkTJ1o3bNhgVItwMw0552bMmGFt3bq1NTIy0tq8eXNrUFCQdc6cOWa1DDfgiN91Q4YMse7Zs8eoFuGGGnLeZWdnWwcPHly9b8GCBdYFCxbUe0xmulxIeXm5cnJylJiYaLM9MTFR2dnZkqQzZ85U/9decXGxduzYoY4dO5reK9xDfc659PR0FRQU6Ouvv9aiRYv0zDPP6MUXX3RGu3AT9TnvLl68qLKyMknSiRMndPjwYd19992m9wr3UZ/zLjY2VmfOnNHFixdVVVWlHTt2qFOnTvUeo/6rv+B0586dU2VlpcLCwmy2h4WF6fTp05L+9csnJSVFVqtVVqtVkyZNUrdu3ZzRLtxAfc45wNHqc959/vnneu655+Th4SGLxaLf/OY3Cg4Odka7cBP1Oe+8vLw0f/58DRgwQFarVYmJiRo2bFi9xyB0uSCLxWLz2mq1Vm+Ljo7W/v37ndAV3Fld59y3jR8/3qSOcDuo67zr16+fDhw44Iy24OZu9vsuKSlJSUlJDarN5UUXEhISIk9PzxozDGfPnq2RzAFH4JyDM3DewRnMOO8IXS7Ex8dH0dHRNb4pkZmZqX79+jmpK7gzzjk4A+cdnMGM847Li43MlStXdOzYserXeXl52r9/v4KDgxUREaG0tDSNHTtWMTEx6tu3r1atWqX8/HxNnDjRiV3DlXHOwRk47+AMTj/vGvAtSxho27ZtVkk1fpKTk6uP+e1vf2uNjIy0+vj4WHv16mX9+OOPndcwXB7nHJyB8w7O4OzzjmcvAgAAmIA1XQAAACYgdAEAAJiA0AUAAGACQhcAAIAJCF0AAAAmIHQBAACYgNAFAABgAkIXAACACQhdAAAAJiB0AQAAmIDQBQAAYAJCF4BGYfz48bJYLDV+hgwZ4uzW7DZ+/HjNmDHjhvtPnz6tF154Qe3bt5efn5/CwsLUv39/vfrqq7p69Wq9xhg+fLgefPDBWvft2rVLFotF+/bta1D/ABzDy9kNAMA3hgwZojVr1ths8/X1NXTM8vJy+fj4GFa/qqpKmzdv1qZNm2rd/9VXX+n+++9X06ZNNX/+fHXt2lXXr1/Xl19+qddee02tWrXSiBEjbjpOSkqKRo8erePHjysyMtJm32uvvaYePXqoV69eDvlMABqGmS4AjYavr6/uuusum59mzZpJkgYNGqTnn39e06dPV3BwsO666y79/Oc/t3m/1WrVggULdPfdd8vf31/du3fXO++8Y3PMoEGDNGnSJKWlpSkkJEQJCQm6fPmynnjiCQUEBKhly5ZasmSJBg0apMmTJ0uS1q1bp+bNm6usrMym1iOPPKJx48bV+Zl27twpDw8P9enTp9b9qamp8vLy0t69e/X444+rU6dO6tq1qx555BFt3rxZw4cPr9fnGzZsmEJDQ7V27Vqb+levXtX69euVkpJSZ58AjEfoAuAyXn/9dQUEBOjTTz/VggULNHfuXGVmZlbv/9nPfqY1a9ZoxYoVOnTokKZMmaInn3xSH3/8cY06Xl5e2rlzp1auXKm0tDTt3LlTmzZtUmZmprKysmwuxT322GOqrKy0ma06d+6c/vKXv+ipp56qs+dNmzZp+PDh8vCo+ev2/Pnz2rp1q3784x8rICCg1vdbLJZ6fT4vLy+NGzdOa9euldVqrX7P22+/rfLycj3xxBN19gnABFYAaASSk5Otnp6e1oCAAJufuXPnWq1Wq3XgwIHW/v3727wnNjbW+tOf/tRqtVqtV65csfr5+Vmzs7NtjklJSbH+4Ac/qH49cOBAa48ePapfFxcXW729va1vv/129bZLly5Z77jjDusLL7xQve1HP/qRNSkpqfr10qVLrXfffbe1qqqqzs/VoUMH66ZNm2rd98knn1glWf/85z/bbG/evHn1558+fXq9P9/nn39ulWT961//Wr1/wIABNp8fgPOwpgtAoxEfH68VK1bYbAsODq7+3926dbPZ17JlS509e1aSdPjwYV27dk0JCQk2x5SXl6tnz54222JiYqr/91dffaWKigr17t27eluTJk3UsWNHm/c888wzio2NVWFhocLDw7VmzZrqxf838vnnn+vEiRM3XOD+je/W2L17t6qqqvTEE09UX9Ksz+f73ve+p379+um1115TfHy8/vGPfygrK0tbt26tc3wA5iB0AWg0AgIC1L59+xvu9/b2tnltsVhUVVUlSdV/bt68WeHh4TbHfXcx/rcv5Vn/fSnuu8HH+q1LdJLUs2dPde/eXevWrdPgwYN14MABffDBB3V+nk2bNikhIUH+/v617m/fvr0sFouOHDlis/3uu++WJJv31ffzpaSkaNKkSfrtb3+rNWvWKDIyUg888ECdfQIwB2u6ALiFzp07y9fXV/n5+Wrfvr3NT5s2bW74vnvuuUfe3t7avXt39bbi4mIdPXq0xrETJkzQmjVr9Nprr+nBBx+ss64kvf/++3V+87B58+ZKSEjQsmXLVFJS4pDP9/jjj8vT01NvvvmmXn/9dT311FN1zsYBMA8zXQAajbKyMp0+fdpmm5eXl0JCQm763sDAQE2bNk1TpkxRVVWV+vfvr+LiYmVnZ+vOO+9UcnLyDd+XnJysn/zkJwoODlZoaKheeukleXh41AgrTzzxhKZNm6bVq1dr3bp1dfZz9uxZ7dmzRxs3bqzzuOXLl+v+++9XTEyMfv7zn6tbt27y8PDQnj17dOTIEUVHR9/S57vzzjs1ZswYzZo1S0VFRRo/fvxN/78DYA5CF4BG48MPP1TLli1ttnXs2LHG5bcb+cUvfqHQ0FClp6frq6++UtOmTdWrVy/NmjWrzvctXrxYEydO1LBhwxQUFKTp06eroKBAfn5+NscFBQVV38rh4YcfrrPmBx98oD59+ig0NLTO4+655x7l5uZq/vz5mjlzpk6cOCFfX1917txZ06ZNU2pq6i1/vpSUFP3+979XYmKiIiIi6hwfgHks1u8uXACA21xJSYnCw8P161//usb9rRISEtSpUye98sorddYYMWKE+vfvr+nTpxvZKgAXwkwXgNtebm6ujhw5ot69e6uoqEhz586VJI0cObL6mAsXLmjr1q3661//qmXLlt20Zv/+/fWDH/zAsJ4BuB5CFwBIWrRokb744gv5+PgoOjpaWVlZNmvJevXqpYsXL+pXv/pVjdtJ1IYZLgDfxeVFAAAAE3DLCAAAABMQugAAAExA6AIAADABoQsAAMAEhC4AAAATELoAAABMQOgCAAAwAaELAADABIQuAAAAExC6AAAATPD/ASjs8EQT+3t7AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select all muons and anti-muons and histogram their energy\n", + "sel = particles.query(\"pdgid in (13, -13)\")\n", + "e = sel[\"energy\"]\n", + "\n", + "# Create new plot\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Use logarithmically sized bins\n", + "bins = np.geomspace(e.min(), e.max(), 20)\n", + "\n", + "# Get the weighted counts (=flux) in each bin\n", + "flux, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"])\n", + "# The error for weighted histograms calculates as follows\n", + "err, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"] ** 2)\n", + "err = np.sqrt(err)\n", + "\n", + "# The differential flux is more informative, so we convert to that\n", + "flux /= np.diff(bins)\n", + "err /= np.diff(bins)\n", + "\n", + "# Plot hist and error bands\n", + "ax.stairs(\n", + " flux,\n", + " bins,\n", + ")\n", + "ax.fill_between(bins[1:], flux - err, flux + err, step=\"pre\", alpha=0.5)\n", + "\n", + "# Add information and double log\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale(\"log\")\n", + "\n", + "ax.set_xlabel(\"Energy / $\\mathrm{GeV}$\")\n", + "ax.set_ylabel(\"Flux $\\Phi_{\\mu^\\pm}\\ /\\ 1/(\\mathrm{m^2 s\\ sr GeV})$\")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "467c8f53-d9cd-41e0-84f2-ff9c7cde8145", + "metadata": {}, + "source": [ + "Now we have a weighted, physical spectrum!\n", + "Keep in mind that while now we see a falling spectrum with approximately $E^{-(3..4)}$, the simulation is very limited and in reality not usable for plotting a muon spectrum. \n", + "As an exercise, you can try to reproduce the same plot, but with the weights from the `GST` model, above." + ] + }, + { + "cell_type": "markdown", + "id": "087e03f4-4fab-459d-be48-0ff82748cb0b", + "metadata": {}, + "source": [ + "## Making use of the `EHIST` Option\n", + "Since the simulation was performed using `CORSIKA7`'s `EHIST` option, we can now divide the muons by their parent-particles. \n", + "Let's see what parent particles are available." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "64d4277b-d01a-4647-992d-92153c92e3d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Parent Particle')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sel = particles.query(\"pdgid in (13, -13)\")\n", + "\n", + "counts = sel.mother_pdgid_cleaned.value_counts()\n", + "counts.index = counts.index.map(\n", + " lambda pid: f\"{Particle.from_pdgid(pid).name} ({pid})\"\n", + " if pid != 0\n", + " else \"unknown (0)\"\n", + ")\n", + "counts.plot(kind=\"bar\", log=True)\n", + "\n", + "plt.ylabel(\"$\\mu^\\pm$ Counts\")\n", + "plt.xlabel(\"Parent Particle\")" + ] + }, + { + "cell_type": "markdown", + "id": "7ed3f62f-e3e3-49cf-a913-85beffd05529", + "metadata": {}, + "source": [ + "We see that most of the mother particles are \"unknown\".\n", + "These unknown particles are assumed to be always pions or (more rarely) kaons.\n", + "This is due to the limitations of `CORSIKA7`'s `EHIST` option.\n", + "With `EHIST`, sometimes the provided so-called \"mother\" particle is not really the direct parent of the \n", + "muon; instead, it's some particle before the observation-level muon in thedecay-chain.\n", + "This can be parsed using the \"Hadron Generation Counter\" provided by the CORSIKA7 output. \n", + "`PANAMA` automatically corrects for that in the \"cleaned\" columns. \n", + "\n", + "TLDR; Due to quirks in CORSIKA7, \"unknown\" are all the pions which can't be further distinguished." + ] + }, + { + "cell_type": "markdown", + "id": "c77d533e-c7a0-41e6-9562-b68cf87a564c", + "metadata": {}, + "source": [ + "Let's plot only the spectrum of the muons coming from $D$-Meson decays, which makes up a huge part of the so-called \"prompt\" spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "390eae1d-259a-442b-b75f-4ef8fe40c36b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select all muons and anti-muons and histogram their energy\n", + "sel = particles.query(\n", + " \"pdgid in (13, -13) and mother_pdgid_cleaned in (423, 421, 413, -413, 421, -411, 411)\"\n", + ")\n", + "e = sel[\"energy\"]\n", + "\n", + "# Create new plot\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Use logarithmically sized bins\n", + "bins = np.geomspace(e.min(), e.max(), 10)\n", + "\n", + "# Get the weighted counts (=flux) in each bin\n", + "flux, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"])\n", + "# The error for weighted histograms calculates as follows\n", + "err, _ = np.histogram(e, bins=bins, weights=sel[\"weight_GSF\"] ** 2)\n", + "err = np.sqrt(err)\n", + "\n", + "# The differential flux is more informative, so we convert to that\n", + "flux /= np.diff(bins)\n", + "err /= np.diff(bins)\n", + "\n", + "# Plot hist and error bands\n", + "ax.stairs(flux, bins)\n", + "ax.fill_between(bins[1:], flux - err, flux + err, step=\"pre\", alpha=0.5)\n", + "\n", + "# Add information and double log\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale(\"log\")\n", + "\n", + "ax.set_xlabel(\"Energy / $\\mathrm{GeV}$\")\n", + "ax.set_ylabel(\"Flux $\\Phi_{\\mu^\\pm}\\ /\\ 1/(\\mathrm{m^2 s\\ sr GeV})$\")\n", + "ax.set_title(\"D-Meson flux only\")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "16c7a56a-9499-417c-aead-8e3ae5bf6fe2", + "metadata": {}, + "source": [ + "Obviously, for this plot to make sense, you need a larger simulation set." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/index.rst b/docs/index.rst index a33994e..d6183f4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -5,12 +5,59 @@ Welcome to PANAMA's documentation! ================================== +.. code-block:: text + + ,-.----. ,--.das nd ____ ulticore utils for corsik 7 + \ / \ ,---, ,--.'| ,---, ,' , `. ,---, + | : \ ' .' \ ,--,: : | ' .' \ ,-+-,.' _ | ' .' \ + | | .\ : / ; '. ,`--.'`| ' : / ; '. ,-+-. ; , || / ; '. + . : |: |: : \ | : : | |: : \ ,--.'|' | ;| : : \ + | | \ :: | /\ \ : | \ | :: | /\ \ | | ,', | ': : | /\ \ + | : . /| : ' ;. : | : ' '; || : ' ;. : | | / | | || | : ' ;. : + ; | |`-' | | ;/ \ \' ' ;. ;| | ;/ \ \' | : | : |, | | ;/ \ \ + | | ; ' : | \ \ ,'| | | \ |' : | \ \ ,'; . | ; |--' ' : | \ \ ,' + : ' | | | ' '--' ' : | ; .'| | ' '--' | : | | , | | ' '--' + : : : | : : | | '`--' | : : | : ' |/ | : : + | | : | | ,' ' : | | | ,' ; | |`-' | | ,' + `---'.| `--'' ; |.' `--'' | ;/ `--'' + `---` '---' '---' + +PANAMA - A python toolkit for `CORSIKA7 `_. + +.. image:: https://img.shields.io/readthedocs/panama?style=for-the-badge + :target: https://panama.readthedocs.io/en/latest/ + :alt: Documentation + +.. image:: https://img.shields.io/github/actions/workflow/status/The-Ludwig/PANAMA/ci.yml?style=for-the-badge + :target: https://github.com/The-Ludwig/PANAMA/actions/workflows/ci.yml + :alt: CI Status +.. image:: https://img.shields.io/github/issues-raw/The-Ludwig/PANAMA?style=for-the-badge + :target: https://github.com/The-Ludwig/PANAMA/issues + :alt: Github issues +.. image:: https://img.shields.io/codecov/c/github/The-Ludwig/PANAMA?label=test%20coverage&style=for-the-badge + :target: https://app.codecov.io/gh/The-Ludwig/PANAMA + :alt: Codecov + +.. image:: https://img.shields.io/pypi/v/corsika-panama?style=for-the-badge + :target: https://pypi.org/project/corsika-panama/ + :alt: PyPI +.. image:: https://img.shields.io/badge/DOI-10.5281%20%2F%20zenodo.10210623-blue.svg?style=for-the-badge + :target: https://doi.org/10.5281/zenodo.10210623 + :alt: DOI +.. image:: https://img.shields.io/github/license/The-Ludwig/PANAMA?style=for-the-badge + :target: https://github.com/The-Ludwig/PANAMA/blob/main/LICENSE + :alt: License +.. image:: https://img.shields.io/badge/codesyle-Black-black.svg?style=for-the-badge + :target: https://github.com/psf/black + :alt: Codestyle Black + + .. toctree:: :maxdepth: 2 :caption: Contents: + Introduction + examples api cli - -.. mdinclude:: ../README.md diff --git a/docs/introduction.md b/docs/introduction.md new file mode 100644 index 0000000..9f826b7 --- /dev/null +++ b/docs/introduction.md @@ -0,0 +1,103 @@ +# Introduction + +## README + +```{include} ../README.md +:heading-offset: 1 +``` + +## Quick Examples + +### Run CORSIKA7 on multiple cores + +You need to have [CORSIKA7](https://www.iap.kit.edu/corsika/79.php) installed to run this. + +Running 100 showers on 4 cores with primary being proton: + +```sh +$ panama run --corsika path/to/corsika7/executable -j4 ./tests/files/example_corsika.template +83%|████████████████████████████████████████████████████▋ | 83.0/100 [00:13<00:02, 6.36shower/s] +Jobs should be nearly finished, now we wait for them to exit +All jobs terminated, cleanup now +``` + +Injecting 5 different primaries (Proton, Helium-4, Carbon-12, Silicon-28, Iron-54 roughly aligning with grouping in H3a) with each primary shower taking 10 jobs: + +```sh +$ panama run --corsika corsika-77420/run/corsika77420Linux_SIBYLL_urqmd --jobs 10 --primary ""{2212: 500, 1000020040: 250, 1000060120: 50, 1000140280: 50, 1000260540: 50}"" ./tests/files/example_corsika.template +,-.----. ,--.das nd ____ ulticore utils for corsik 7 +\ / \ ,---, ,--.'| ,---, ,' , `. ,---, +| : \ ' .' \ ,--,: : | ' .' \ ,-+-,.' _ | ' .' \ +| | .\ : / ; '. ,`--.'`| ' : / ; '. ,-+-. ; , || / ; '. +. : |: |: : \ | : : | |: : \ ,--.'|' | ;| : : \ +| | \ :: | /\ \ : | \ | :: | /\ \ | | ,', | ': : | /\ \ +| : . /| : ' ;. : | : ' '; || : ' ;. : | | / | | || | : ' ;. : +; | |`-' | | ;/ \ \' ' ;. ;| | ;/ \ \' | : | : |, | | ;/ \ \ +| | ; ' : | \ \ ,'| | | \ |' : | \ \ ,'; . | ; |--' ' : | \ \ ,' +: ' | | | ' '--' ' : | ; .'| | ' '--' | : | | , | | ' '--' +: : : | : : | | '`--' | : : | : ' |/ | : : +| | : | | ,' ' : | | | ,' ; | |`-' | | ,' +`---'.| `--'' ; |.' `--'' | ;/ `--'' + `---` '---' '---' v0.7.2 +... +``` + +### Read CORSIKA7 DAT files to pandas dataframes + +Example: Calculate mean energy in the corsika files created in the example above: + +``` +In [1]: import panama as pn + +In [2]: run_header, event_header, particles = pn.read_DAT(glob="corsika_output/DAT*") +100%|████████████████████████████████████████████████████████████| 2000/2000.0 [00:00<00:00, 10127.45it/s] +In [3]: particles["energy"].mean() +Out[3]: 26525.611020413744 +``` + +`run_header`, `event_header` and `particles` are all [pandas.DataFrames](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) and can conveniently be used. + +If `CORSIKA7` is compiled with the `EHIST` option, then the mother particles are automatically deleted, by default (this behaviour can be changed with`drop_mothers=False`). +If you want additional columns in the real particles storing the mother information use `mother_columns=True`. + +### Convert CORSIKA7 DAT files to hdf5 files + +For this you need to have [PyTables](https://github.com/PyTables/PyTables) installed. +You can do that if via `pip install corsika-panama[hdf]`. + +```sh +$ panama hdf5 path/to/corsika/dat/files/DAT* output.hdf5 +``` + +The data is available under the `run_header` `event_header` and `particles` key. + +### Weighting to primary spectrum + +This packages also provides facility to add a `weight` column to the dataframe, so you can look at corsika-output +in physical flux in terms of $(\mathrm{m^2} \mathrm{s}\ \mathrm{sr}\ \mathrm{GeV})^{-1}$. +Using the example above, to get the whole physical flux in the complete simulated energy region: + +``` +In [1]: import panama as pn + +In [2]: run_header, event_header, particles = pn.read_DAT(glob="corsika_output/DAT*") +100%|████████████████████████████████████████████████████████████| 2000/2000.0 [00:00<00:00, 10127.45it/s] +In [3]: particles["weight"] = pn.get_weights(run_header, event_header, particles) + +In [4]: particles["weight"].sum()*(run_header["energy_max"]-run_header["energy_min"]) +Out[4]: +run_number +1.0 1234.693481 +0.0 1234.693481 +3.0 1234.693481 +2.0 1234.693481 +dtype: float32 + +``` + +Which is in units of $(\mathrm{m^2}\ \mathrm{s}\ \mathrm{sr})^{-1}$. We get a result for each run, since +in theory we could have different energy regions. Here, we do not, so the result is always equal. + +Weighting can be applied to different primaries, also, if they are known by the flux model. + +`add_weight` can also be applied to dataframes loaded in from hdf5 files produced with PANAMA. diff --git a/docs/requirements.txt b/docs/requirements.txt index 6c2b6d6..b5a3303 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,4 +1,5 @@ -sphinx_rtd_theme -m2r2 +nbsphinx +myst_parser sphinx_click corsika-panama +pydata-sphinx-theme diff --git a/panama/nbstreamreader.py b/panama/_nbstreamreader.py similarity index 89% rename from panama/nbstreamreader.py rename to panama/_nbstreamreader.py index c603b60..8d6418c 100644 --- a/panama/nbstreamreader.py +++ b/panama/_nbstreamreader.py @@ -1,4 +1,9 @@ -# Adapted from http://eyalarubas.com/python-subproc-nonblock.html +""" +A non-blocking stream reader used to read output from +multiple running CORSIKA instances. +Only to be used internally. +Adapted from http://eyalarubas.com/python-subproc-nonblock.html +""" from __future__ import annotations from queue import Empty, Queue diff --git a/panama/cli/corsika_to_hdf5.py b/panama/cli/corsika_to_hdf5.py index 7c38582..8eda295 100644 --- a/panama/cli/corsika_to_hdf5.py +++ b/panama/cli/corsika_to_hdf5.py @@ -13,6 +13,12 @@ @click.command(context_settings={"show_default": True}) @click.argument("input", type=click.Path(exists=True, dir_okay=False), nargs=-1) @click.argument("output", type=click.Path(exists=False, dir_okay=False), nargs=1) +@click.option( + "--comp", + "-c", + help="Sets a compression level between 0 and 9. 0 means no compression.", + default=5, +) @click.option( "--noadd", "-n", @@ -41,6 +47,7 @@ def hdf5( input: list[Path], output: Path, + comp: int, noadd: bool, mother: bool, dropmother: bool, @@ -89,6 +96,6 @@ def hdf5( drop_non_particles=dropnonparticles, ) - run_header.to_hdf(output, "run_header") - event_header.to_hdf(output, "event_header") - particles.to_hdf(output, "particles") + run_header.to_hdf(output, "run_header", complevel=comp) + event_header.to_hdf(output, "event_header", complevel=comp) + particles.to_hdf(output, "particles", complevel=comp) diff --git a/panama/cli/run.py b/panama/cli/run.py index aa2ce62..ca447f8 100644 --- a/panama/cli/run.py +++ b/panama/cli/run.py @@ -164,7 +164,7 @@ def run( "Looks like --events was given and --primary was provided a dict. --events is ignored." ) - runner = CorsikaRunner( + with CorsikaRunner( primary, jobs, template, @@ -175,5 +175,5 @@ def run( save_std, first_run_number, first_event_number, - ) - runner.run() + ) as runner: + runner.run() diff --git a/panama/constants.py b/panama/constants.py index 867f3f6..64b9d9a 100644 --- a/panama/constants.py +++ b/panama/constants.py @@ -1,3 +1,6 @@ +""" +Some constants used across multiple modules +""" from particle import PDGID, Particle D0_LIFETIME = Particle.from_name("D0").lifetime diff --git a/panama/prompt.py b/panama/prompt.py index 9c2d0e3..d8163ee 100644 --- a/panama/prompt.py +++ b/panama/prompt.py @@ -1,3 +1,7 @@ +""" +Functions to use to determine if a particle is prompt or not, +using multiple different definitions. +""" from __future__ import annotations from math import inf @@ -51,7 +55,7 @@ def is_prompt_lifetime_limit( def add_cleaned_mother_cols(df_particles: pd.DataFrame) -> None: """ - Adds mother_lifetime_cleaned, mother_mass_cleaned and mother_energy_cleaned if not present in the dataframe + Adds mother_lifetime_cleaned, mother_mass_cleaned and mother_energy_cleaned if not present in the dataframe. """ if "mother_lifetime_cleaned" not in df_particles: pdgids = df_particles["mother_pdgid_cleaned"].unique() @@ -98,9 +102,11 @@ def is_prompt_lifetime_limit_cleaned( ) -> ArrayLike: """Return a numpy array of prompt labels for the input dataframe differentiating it by lifetime of the mother particle. It considers the cleaned particle type of the mother. + Parameters ---------- df_particles: dataframe with the corsika particles, additional_columns have to be present when running `read_DAT` + Returns ------- A numpy boolean array, True for prompt, False for conventional @@ -119,10 +125,12 @@ def is_prompt_lifetime_limit_cleaned( def is_prompt_energy(df_particles: pd.DataFrame, s: float = 2) -> ArrayLike: """Return a numpy array of prompt labels for the input dataframe differentiating it by energy of the mother particle, with considering the cleaned particle type of the mother. + Parameters ---------- df_particles: dataframe with the corsika particles, additional_columns have to be present when running `read_DAT` s: scaling factor. How much bigger does the decay length has to be compared to the interaction length + Returns ------- A numpy boolean array, True for prompt, False for conventional diff --git a/panama/read.py b/panama/read.py index 6f2d7b5..a32650d 100644 --- a/panama/read.py +++ b/panama/read.py @@ -1,3 +1,7 @@ +""" +Functions concerning input of CORSIKA7 DAT files. +""" + from __future__ import annotations from math import inf @@ -35,6 +39,9 @@ def read_DAT( Read CORSIKA DAT files to Pandas.DataFrame. Exactly one of `files` or `glob` must be provided. Made for CORSIKA>7.4, other compatibility not garantueed, but probably approximate. + All energies and masses are given in :math:`\mathrm{GeV}`, while lifetimes are given + in :math:`\mathrm{ns}`. + All other units follow the CORSIKA7 definitions, look at its userguide. Parameters ---------- @@ -96,7 +103,7 @@ def read_DAT( DataFrame with the information about each event particles: pandas.DataFrame DataFrame with the information about each particle - """ + """ # noqa: W605 if files is None and glob is None: raise ValueError("`file` and `glob` can't both be None") @@ -322,7 +329,7 @@ def add_mother_columns( ) -> None: """ Adds the information from mother and grandmother rows to - the particle column. + the column of the daughter particle. This looks so complicated, since in the table different rows depend on each other. To do this in a numpy-friendly way is not diff --git a/panama/run.py b/panama/run.py index 0c55015..2e1687f 100644 --- a/panama/run.py +++ b/panama/run.py @@ -1,4 +1,6 @@ -#!/usr/bin/env python3 +""" +Classes handling the parallel execution of CORSIKA7 processes. +""" from __future__ import annotations import io @@ -11,11 +13,12 @@ from random import seed as set_seed from subprocess import PIPE, Popen, TimeoutExpired from time import sleep +from types import TracebackType from particle import Corsika7ID, Particle from tqdm import tqdm -from .nbstreamreader import NonBlockingStreamReader as NBSR +from ._nbstreamreader import NonBlockingStreamReader as NBSR CORSIKA_FILE_ERROR = "STOP FILOPN: FATAL PROBLEM OPENING FILE" CORSIKA_EVENT_FINISHED = b"PRIMARY PARAMETERS AT FIRST INTERACTION POINT AT HEIGHT" @@ -25,9 +28,31 @@ class CorsikaJob: + """ + This class handles the execution and monitoring of one single CORSIKA7 process. + Usually, there should be no need to use this class directly, use CorsikaRunner instead. + """ + def __init__( self, corsika_executable: Path, corsika_copy_dir: Path, card_template: str ) -> None: + """ + + Parameters + ---------- + corsika_executable : Path + Path of the CORSIKA7 executable. + corsika_copy_dir : Path + The path to where the original executable will be symlinked, + so it can be run multiple times in parallel. + CORSIKA7 for some reason does not allow running the same executable + multiple times. + card_template : str + The string containing a valid CORSIKA7 run card with additional + python-like templates (e.g. `{emin}`). + The template will be formatted when calling start. + + """ self.corsika_copy_dir = corsika_copy_dir self.corsika_copy_dir.mkdir(parents=True, exist_ok=False) self.card_template = card_template @@ -47,16 +72,39 @@ def __init__( self.output = b"" self.save_std_file: None | io.TextIOWrapper = None - def __del__(self) -> None: - shutil.rmtree(self.corsika_copy_dir) + def clean(self) -> None: + """ + Cleans the temporary directory. + """ + shutil.rmtree(self.corsika_copy_dir, ignore_errors=True) @property def is_finished(self) -> bool: + """ + Returns True if the process is not running, False otherwise + """ return self.running is None def start( self, corsika_config: dict[str, str], save_std: Path | None = None ) -> None: + """ + Starts the CORSIKA7 process with the given parameters, if it is not + already running. + + Parameters + ---------- + corsika_config : dict[str, str] + The template values which will be filled in the template corsika card. + save_std : Path | None, optional + If provided, the std output of CORSIKA7 will be saved to this path. + + Raises + ------ + RuntimeError + If the process is already running. + + """ if self.running is not None: raise RuntimeError("Can't use this CorsikaJob, it's still running!") @@ -97,6 +145,8 @@ def start( def poll(self) -> int | None: """ + Returns how many showers finished since last poll or None if the process is finished. + Returns ------- n_update: The number of showers finished since last poll or None if process is finished @@ -136,9 +186,16 @@ def poll(self) -> int | None: def join(self) -> int: """ + Waits for the CORSIKA7 process to finish, if it is running. + Returns ------- - n_update: The number of finished events in the last output + n_update: The number of finished events in the last output. + + Raises + ------ + RuntimeError + If the process is already finished. """ if self.running is None: raise RuntimeError("Job is already finished") @@ -185,6 +242,15 @@ def _reset(self) -> None: class CorsikaRunner: + """ + This class manages running multiple CORSIKA7 processes in parallel, by splitting + up the requested showers in badges and changing the initial seeds for CORSIKA7 for + each batch. + It also provides a progressbar by investigating the stdout from CORSIKA7. + To automatically clean up temporary directories, this class can be used in a + `with`-statement. Otherwise, call `corsika_runner.clean()` to delete the tmp dirs. + """ + def __init__( self, primary: dict[int, int], @@ -199,14 +265,77 @@ def __init__( first_event_number: int = 1, ) -> None: """ - TODO: Docstring + This class manages running multiple CORSIKA7 processes in parallel, by splitting + up the requested showers in badges and changing the initial seeds for CORSIKA7 for + each batch. + It also provides a progressbar by investigating the stdout from CORSIKA7. + This means that "parallelization" is handled by the operating system. If you are only + allowed to use one core, this will not parallelize anything. Parameters ---------- + primary : dict[int, int] + Mapping from PDGID to number of events with this primary. + 10 Proton and 20 Helium-4 air showers would mean `{2212: 10, 1000020040: 20}`. + (Use the proton pdgid, not the Hydrogen-1 pdgid!) + Conversion between pdgid and Corsika7ID is handled by the particle python package. + All primaries of one type are processed parallel, and the different + primaries are processed after each other. + This guarantees, that each progress running parallel at a time + will approximately run an equal amount of time. + + n_jobs : int + The number of parallel jobs to send to the operating system. + + template_path : Path + The path to the template of the CORISKA7 card. + + output : Path + The path where the CORSIKA7 process will produce the output. + + corsika_executable : Path + The path to the CORSIKA7 executable. + + corsika_tmp_dir : Path + A temporary directory to symlink the CORSIKA7 executable to. + Since CORSIKA7 can not be run in parallel from the same executable + directly. + The copied/symlinked files will be deleted automatically when used + in a context manager (`with`-statement), otherwise you have to call + the `clean()` method. + The directory itself will not be deleted, only the used subdir in the + directory. + + seed : None | int, optional + The seed to use for generating the seeds for the CORSIKA7 program. + If None is given, entropic source of the computer will be used. + + save_std : bool, optional + Whether or not to save the standard output of the CORSIKA7 programs. + If true, the output is available as "prim{pdgid}_job{jobid}.log" in the + output folder. + + first_run_number : int = 0, optional + The run number the first run will get. + All following runs will increment the run number by one. + + first_event_number : int = 1, optional + The event number the first event in each run will get. + + Raises + ------ + ValueError + If the input is not consistent. + """ self.primary = primary self.n_jobs = n_jobs self.output = Path(output) + if self.output.exists(): + logger.warning( + f"Output Directory ({self.output.absolute()}) already exists. CORSIKA7 will crash if an output file already exists. Consider removing the directory before running the simulation." + ) + self.corsika_executable = Path(corsika_executable) self.corsika_tmp_dir = Path(corsika_tmp_dir) self.save_std = save_std @@ -236,11 +365,23 @@ def __init__( ) ) - def wait_for_jobs(self) -> None: + def _wait_for_jobs(self, disable_pb: bool = False) -> None: + """ + Wait until all jobs are finished. This is called automatically by run at the moment. + + + Parameters + ---------- + disable_pb : bool + If True, disables the progressbar. + + """ n_events = sum([job.n_showers for job in self.job_pool]) # show progressbar until close to end try: - with tqdm(total=n_events, unit="shower", unit_scale=True) as pbar: + with tqdm( + total=n_events, unit="shower", unit_scale=True, disable=disable_pb + ) as pbar: while not all(job.is_finished for job in self.job_pool): for job in self.job_pool: update = job.poll() @@ -251,7 +392,41 @@ def wait_for_jobs(self) -> None: except KeyboardInterrupt: # pragma: no cover logger.info("Interrupted by user.") - def run(self) -> None: + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.clean() + + def __enter__(self) -> CorsikaRunner: + return self + + def __del__(self) -> None: + self.clean() + + def clean(self) -> None: + """ + Deletes the temporary directories, this is called when the object is deleted. + This method has to be called, before a different CorsikaRunner with the + same tmp_dir can be constructed. + The object can't be used anymore after calling this method. + """ + for job in self.job_pool: + job.clean() + + def run(self, disable_pb: bool = False) -> None: + """ + Start all the processes and wait for them to finish. + Each primary element is run after another. + + Parameters + ---------- + disable_pb : bool + If True, disables the (tqdm) progressbar. + + """ # create dir if not existent self.output.mkdir(parents=True, exist_ok=True) @@ -298,7 +473,7 @@ def run(self) -> None: save_std_path, ) - self.wait_for_jobs() + self._wait_for_jobs(disable_pb) def _get_corsika_config( self, diff --git a/panama/version.py b/panama/version.py index 43b6fe9..db230cb 100644 --- a/panama/version.py +++ b/panama/version.py @@ -9,7 +9,7 @@ __distribution__ = pkgs["panama"][0] if "panama" in pkgs else "corsika-panama" # __version__ = version(__distribution__) -__version__ = "0.9.1" +__version__ = "1.0.0" LOGO_TEMPLATE = r""" ,-.----. ,--.das nd ____ ulticore utils for corsik 7 diff --git a/panama/weights.py b/panama/weights.py index e771c85..107f69d 100644 --- a/panama/weights.py +++ b/panama/weights.py @@ -1,6 +1,9 @@ """ -Functions to add weights to the read in corsika dataframe -""" +Functions to add weights to a CORSIKA dataframe read in by `read_DAT`. +If using the suggested flux definitions from `fluxcomp`, all fluxes +are given in units of :math:`(\mathrm{m^2}\ \mathrm{s}\ \mathrm{sr}\ \mathrm{GeV})^{-1}`. + +""" # noqa: W605 from __future__ import annotations from typing import Any @@ -24,21 +27,28 @@ def get_weights( groups: dict[PDGID, tuple[int, int]] | None = None, ) -> pd.DataFrame: """ - Adds the column "weight" too df_particle to reweight for given primary flux. + Returns a DataFrame with the correct weight for a given primary model + The DataFrame will be indexed by the run and event index, so it can be + assigned as a column to the particle DataFrame df. + + The primary energy can have different energy-regions, but they must not overlap, + if they do, an error is raised. Parameters ---------- - df_run: The run dataframe (as returned by `read_corsika_particle_files_to_dataframe`) - df_event: The event dataframe (as returned by `read_corsika_particle_files_to_dataframe`) - df: The particle dataframe (as returned by `read_corsika_particle_files_to_dataframe`) - model: The Cosmic Ray primary flux model (instance of CRFlux) - proton_only: If set to true (default), only proton pdgid weights are non-zero and refer to + df_run: The run dataframe (as returned by `panama.read_DAT`) + df_event: The event dataframe (as returned by `panama.read_DAT`) + df: The particle dataframe (as returned by `panama.read_DAT`) + model: The Cosmic Ray primary flux model (instance of CRFlux from the FluxComp package) + proton_only: If set to true (default is false), only proton pdgid weights are non-zero and refer to all-nucleon flux. - groups: The elements in the model (values: Tuple[Zmin, Zmax]) associated with the MC-primary + groups: Mapping from the primary PDGID in the monte carlo, to an (inclusive) range of elements (represented by their atomic number) which will we summed up in the + model to represent this element in MC. (values: Tuple[Zmin, Zmax]) Returns ------- weights: A dataframe with the weights labeled by the run and event index. + Can be used like this: `df['weights'] = panama.get_weights(df_run, df_event, df)` """ if groups is not None and proton_only is True: @@ -127,7 +137,14 @@ def add_weight_prompt( is_prompt_col_name: str = "is_prompt", ) -> None: """ - Adds column "weight_prompt" to df, to set a weight for every prompt particle, non prompt particles get weight 1 + Adds column "weight_prompt" to df, to set a weight for every prompt particle, non prompt particles get weight 1. + + Parameters + ---------- + df: The particle dataframe (as returned by `panama.read_DAT`) + prompt_factor: The number to put in the `weight_prompt` column. + weight_col_name: The column name to give for the prompt weight column (default 'weight_prompt'). + is_prompt_col_name: The name of the column which indicates the promptness of a particle. """ if not df.index.is_monotonic_increasing: df.sort_index(inplace=True) @@ -147,6 +164,13 @@ def add_weight_prompt_per_event( """ Adds column "weight_prompt_per_event" to df, which will be `prompt_factor` for every particle, which is inside a shower, which has at least one prompt muon. For every other particle, it will be 1. + + Parameters + ---------- + df: The particle dataframe (as returned by `panama.read_DAT`) + prompt_factor: The number to put in the `weight_prompt` column. + weight_col_name: The column name to give for the prompt weight column (default 'weight_prompt_per_event'). + is_prompt_col_name: The name of the column which indicates the promptness of a particle (default: 'is_prompt'). """ # For some weird reason this makes a difference, as the last line of this function does not work otherwise if not df.index.is_monotonic_increasing: # pragma: no cover diff --git a/pdm.lock b/pdm.lock index 523cf72..feb87e0 100644 --- a/pdm.lock +++ b/pdm.lock @@ -4,8 +4,20 @@ [metadata] groups = ["default", "dev", "hdf"] strategy = ["cross_platform"] -lock_version = "4.4" -content_hash = "sha256:2c85793df3de95fc43d4364955c925b33215f57a0e14d950e4d5ab05e1345154" +lock_version = "4.4.1" +content_hash = "sha256:841616f19ebdf6cfc93ad4b8292b98d3747ecd22d145988992325f2b0321245a" + +[[package]] +name = "accessible-pygments" +version = "0.0.4" +summary = "A collection of accessible pygments styles" +dependencies = [ + "pygments>=1.5", +] +files = [ + {file = "accessible-pygments-0.0.4.tar.gz", hash = "sha256:e7b57a9b15958e9601c7e9eb07a440c813283545a20973f2574a5f453d0e953e"}, + {file = "accessible_pygments-0.0.4-py2.py3-none-any.whl", hash = "sha256:416c6d8c1ea1c5ad8701903a20fcedf953c6e720d64f33dc47bfb2d3f2fa4e8d"}, +] [[package]] name = "alabaster" @@ -17,6 +29,22 @@ files = [ {file = "alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2"}, ] +[[package]] +name = "anyio" +version = "4.2.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.2.0-py3-none-any.whl", hash = "sha256:745843b39e829e108e518c489b31dc757de7d2131d53fac32bd8df268227bfee"}, + {file = "anyio-4.2.0.tar.gz", hash = "sha256:e1875bb4b4e2de1669f4bc7869b6d3f54231cdced71605e6e64c9be77e3be50f"}, +] + [[package]] name = "appnope" version = "0.1.3" @@ -26,6 +54,65 @@ files = [ {file = "appnope-0.1.3.tar.gz", hash = "sha256:02bd91c4de869fbb1e1c50aafc4098827a7a54ab2f39d9dcba6c9547ed920e24"}, ] +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +dependencies = [ + "argon2-cffi-bindings", +] +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]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +dependencies = [ + "cffi>=1.0.1", +] +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]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + [[package]] name = "asttokens" version = "2.4.1" @@ -38,6 +125,19 @@ files = [ {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, ] +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +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]] name = "attrs" version = "23.1.0" @@ -70,6 +170,19 @@ files = [ {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, ] +[[package]] +name = "beautifulsoup4" +version = "4.12.2" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.2-py3-none-any.whl", hash = "sha256:bd2520ca0d9d7d12694a53d44ac482d181b4ec1888909b035a3dbf40d0f57d4a"}, + {file = "beautifulsoup4-4.12.2.tar.gz", hash = "sha256:492bbc69dca35d12daac71c4db1bfff0c876c00ef4a2ffacce226d4638eb72da"}, +] + [[package]] name = "black" version = "22.12.0" @@ -96,6 +209,20 @@ files = [ {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, ] +[[package]] +name = "bleach" +version = "6.1.0" +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +dependencies = [ + "six>=1.9.0", + "webencodings", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + [[package]] name = "blosc2" version = "2.0.0" @@ -138,6 +265,59 @@ files = [ {file = "certifi-2023.7.22.tar.gz", hash = "sha256:539cc1d13202e33ca466e88b2807e29f4c13049d6d87031a3c110744495cb082"}, ] +[[package]] +name = "cffi" +version = "1.16.0" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +dependencies = [ + "pycparser", +] +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-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]] name = "cfgv" version = "3.4.0" @@ -251,6 +431,19 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +[[package]] +name = "comm" +version = "0.2.1" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.1-py3-none-any.whl", hash = "sha256:87928485c0dfc0e7976fd89fc1e187023cf587e7c353e4a9b417555b44adf021"}, + {file = "comm-0.2.1.tar.gz", hash = "sha256:0bc91edae1344d39d3661dcbc36937181fdaddb304790458f8b044dbc064b89a"}, +] + [[package]] name = "contourpy" version = "1.1.1" @@ -307,65 +500,65 @@ files = [ [[package]] name = "corsikaio" -version = "0.3.4" +version = "0.4.0" requires_python = ">=3.8" summary = "Reader for corsika binary output files using numpy" dependencies = [ "numpy", ] files = [ - {file = "corsikaio-0.3.4-py3-none-any.whl", hash = "sha256:8d83b9f5bf4aad20e8c4456d40ff55f4299c5b7da3344cc9027a771746130a0e"}, - {file = "corsikaio-0.3.4.tar.gz", hash = "sha256:ce8d222dc991e238baa8b4b0e509a59670fb9f9823add3313b44beeef1ec2dbf"}, + {file = "corsikaio-0.4.0-py3-none-any.whl", hash = "sha256:822ab5cd950b1713c4b0fcf5929300093622edcb68ea8d6b818faf9bb4e28de5"}, + {file = "corsikaio-0.4.0.tar.gz", hash = "sha256:3902b52c460a04ae24a54167c551d4fb825b67e0be97887d34f0e175224d302d"}, ] [[package]] name = "coverage" -version = "7.3.2" +version = "7.4.0" requires_python = ">=3.8" summary = "Code coverage measurement for Python" files = [ - {file = "coverage-7.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d872145f3a3231a5f20fd48500274d7df222e291d90baa2026cc5152b7ce86bf"}, - {file = "coverage-7.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:310b3bb9c91ea66d59c53fa4989f57d2436e08f18fb2f421a1b0b6b8cc7fffda"}, - {file = "coverage-7.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f47d39359e2c3779c5331fc740cf4bce6d9d680a7b4b4ead97056a0ae07cb49a"}, - {file = "coverage-7.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa72dbaf2c2068404b9870d93436e6d23addd8bbe9295f49cbca83f6e278179c"}, - {file = "coverage-7.3.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:beaa5c1b4777f03fc63dfd2a6bd820f73f036bfb10e925fce067b00a340d0f3f"}, - {file = "coverage-7.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:dbc1b46b92186cc8074fee9d9fbb97a9dd06c6cbbef391c2f59d80eabdf0faa6"}, - {file = "coverage-7.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:315a989e861031334d7bee1f9113c8770472db2ac484e5b8c3173428360a9148"}, - {file = "coverage-7.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d1bc430677773397f64a5c88cb522ea43175ff16f8bfcc89d467d974cb2274f9"}, - {file = "coverage-7.3.2-cp310-cp310-win32.whl", hash = "sha256:a889ae02f43aa45032afe364c8ae84ad3c54828c2faa44f3bfcafecb5c96b02f"}, - {file = "coverage-7.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c0ba320de3fb8c6ec16e0be17ee1d3d69adcda99406c43c0409cb5c41788a611"}, - {file = "coverage-7.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ac8c802fa29843a72d32ec56d0ca792ad15a302b28ca6203389afe21f8fa062c"}, - {file = "coverage-7.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:89a937174104339e3a3ffcf9f446c00e3a806c28b1841c63edb2b369310fd074"}, - {file = "coverage-7.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e267e9e2b574a176ddb983399dec325a80dbe161f1a32715c780b5d14b5f583a"}, - {file = "coverage-7.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2443cbda35df0d35dcfb9bf8f3c02c57c1d6111169e3c85fc1fcc05e0c9f39a3"}, - {file = "coverage-7.3.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4175e10cc8dda0265653e8714b3174430b07c1dca8957f4966cbd6c2b1b8065a"}, - {file = "coverage-7.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0cbf38419fb1a347aaf63481c00f0bdc86889d9fbf3f25109cf96c26b403fda1"}, - {file = "coverage-7.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:5c913b556a116b8d5f6ef834038ba983834d887d82187c8f73dec21049abd65c"}, - {file = "coverage-7.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1981f785239e4e39e6444c63a98da3a1db8e971cb9ceb50a945ba6296b43f312"}, - {file = "coverage-7.3.2-cp311-cp311-win32.whl", hash = "sha256:43668cabd5ca8258f5954f27a3aaf78757e6acf13c17604d89648ecc0cc66640"}, - {file = "coverage-7.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10c39c0452bf6e694511c901426d6b5ac005acc0f78ff265dbe36bf81f808a2"}, - {file = "coverage-7.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f94b734214ea6a36fe16e96a70d941af80ff3bfd716c141300d95ebc85339738"}, - {file = "coverage-7.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:af3d828d2c1cbae52d34bdbb22fcd94d1ce715d95f1a012354a75e5913f1bda2"}, - {file = "coverage-7.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:630b13e3036e13c7adc480ca42fa7afc2a5d938081d28e20903cf7fd687872e2"}, - {file = "coverage-7.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9eacf273e885b02a0273bb3a2170f30e2d53a6d53b72dbe02d6701b5296101c"}, - {file = "coverage-7.3.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8f17966e861ff97305e0801134e69db33b143bbfb36436efb9cfff6ec7b2fd9"}, - {file = "coverage-7.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b4275802d16882cf9c8b3d057a0839acb07ee9379fa2749eca54efbce1535b82"}, - {file = "coverage-7.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:72c0cfa5250f483181e677ebc97133ea1ab3eb68645e494775deb6a7f6f83901"}, - {file = "coverage-7.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cb536f0dcd14149425996821a168f6e269d7dcd2c273a8bff8201e79f5104e76"}, - {file = "coverage-7.3.2-cp38-cp38-win32.whl", hash = "sha256:307adb8bd3abe389a471e649038a71b4eb13bfd6b7dd9a129fa856f5c695cf92"}, - {file = "coverage-7.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:88ed2c30a49ea81ea3b7f172e0269c182a44c236eb394718f976239892c0a27a"}, - {file = "coverage-7.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b631c92dfe601adf8f5ebc7fc13ced6bb6e9609b19d9a8cd59fa47c4186ad1ce"}, - {file = "coverage-7.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d3d9df4051c4a7d13036524b66ecf7a7537d14c18a384043f30a303b146164e9"}, - {file = "coverage-7.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f7363d3b6a1119ef05015959ca24a9afc0ea8a02c687fe7e2d557705375c01f"}, - {file = "coverage-7.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f11cc3c967a09d3695d2a6f03fb3e6236622b93be7a4b5dc09166a861be6d25"}, - {file = "coverage-7.3.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:149de1d2401ae4655c436a3dced6dd153f4c3309f599c3d4bd97ab172eaf02d9"}, - {file = "coverage-7.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:3a4006916aa6fee7cd38db3bfc95aa9c54ebb4ffbfc47c677c8bba949ceba0a6"}, - {file = "coverage-7.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9028a3871280110d6e1aa2df1afd5ef003bab5fb1ef421d6dc748ae1c8ef2ebc"}, - {file = "coverage-7.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9f805d62aec8eb92bab5b61c0f07329275b6f41c97d80e847b03eb894f38d083"}, - {file = "coverage-7.3.2-cp39-cp39-win32.whl", hash = "sha256:d1c88ec1a7ff4ebca0219f5b1ef863451d828cccf889c173e1253aa84b1e07ce"}, - {file = "coverage-7.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b4767da59464bb593c07afceaddea61b154136300881844768037fd5e859353f"}, - {file = "coverage-7.3.2-pp38.pp39.pp310-none-any.whl", hash = "sha256:ae97af89f0fbf373400970c0a21eef5aa941ffeed90aee43650b81f7d7f47637"}, - {file = "coverage-7.3.2.tar.gz", hash = "sha256:be32ad29341b0170e795ca590e1c07e81fc061cb5b10c74ce7203491484404ef"}, + {file = "coverage-7.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:36b0ea8ab20d6a7564e89cb6135920bc9188fb5f1f7152e94e8300b7b189441a"}, + {file = "coverage-7.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0676cd0ba581e514b7f726495ea75aba3eb20899d824636c6f59b0ed2f88c471"}, + {file = "coverage-7.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0ca5c71a5a1765a0f8f88022c52b6b8be740e512980362f7fdbb03725a0d6b9"}, + {file = "coverage-7.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7c97726520f784239f6c62506bc70e48d01ae71e9da128259d61ca5e9788516"}, + {file = "coverage-7.4.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:815ac2d0f3398a14286dc2cea223a6f338109f9ecf39a71160cd1628786bc6f5"}, + {file = "coverage-7.4.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:80b5ee39b7f0131ebec7968baa9b2309eddb35b8403d1869e08f024efd883566"}, + {file = "coverage-7.4.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5b2ccb7548a0b65974860a78c9ffe1173cfb5877460e5a229238d985565574ae"}, + {file = "coverage-7.4.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:995ea5c48c4ebfd898eacb098164b3cc826ba273b3049e4a889658548e321b43"}, + {file = "coverage-7.4.0-cp310-cp310-win32.whl", hash = "sha256:79287fd95585ed36e83182794a57a46aeae0b64ca53929d1176db56aacc83451"}, + {file = "coverage-7.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:5b14b4f8760006bfdb6e08667af7bc2d8d9bfdb648351915315ea17645347137"}, + {file = "coverage-7.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:04387a4a6ecb330c1878907ce0dc04078ea72a869263e53c72a1ba5bbdf380ca"}, + {file = "coverage-7.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ea81d8f9691bb53f4fb4db603203029643caffc82bf998ab5b59ca05560f4c06"}, + {file = "coverage-7.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:74775198b702868ec2d058cb92720a3c5a9177296f75bd97317c787daf711505"}, + {file = "coverage-7.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76f03940f9973bfaee8cfba70ac991825611b9aac047e5c80d499a44079ec0bc"}, + {file = "coverage-7.4.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:485e9f897cf4856a65a57c7f6ea3dc0d4e6c076c87311d4bc003f82cfe199d25"}, + {file = "coverage-7.4.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6ae8c9d301207e6856865867d762a4b6fd379c714fcc0607a84b92ee63feff70"}, + {file = "coverage-7.4.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bf477c355274a72435ceb140dc42de0dc1e1e0bf6e97195be30487d8eaaf1a09"}, + {file = "coverage-7.4.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:83c2dda2666fe32332f8e87481eed056c8b4d163fe18ecc690b02802d36a4d26"}, + {file = "coverage-7.4.0-cp311-cp311-win32.whl", hash = "sha256:697d1317e5290a313ef0d369650cfee1a114abb6021fa239ca12b4849ebbd614"}, + {file = "coverage-7.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:26776ff6c711d9d835557ee453082025d871e30b3fd6c27fcef14733f67f0590"}, + {file = "coverage-7.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d1bf53c4c8de58d22e0e956a79a5b37f754ed1ffdbf1a260d9dcfa2d8a325e"}, + {file = "coverage-7.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:109f5985182b6b81fe33323ab4707011875198c41964f014579cf82cebf2bb85"}, + {file = "coverage-7.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cc9d4bc55de8003663ec94c2f215d12d42ceea128da8f0f4036235a119c88ac"}, + {file = "coverage-7.4.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cc6d65b21c219ec2072c1293c505cf36e4e913a3f936d80028993dd73c7906b1"}, + {file = "coverage-7.4.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a10a4920def78bbfff4eff8a05c51be03e42f1c3735be42d851f199144897ba"}, + {file = "coverage-7.4.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b8e99f06160602bc64da35158bb76c73522a4010f0649be44a4e167ff8555952"}, + {file = "coverage-7.4.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:7d360587e64d006402b7116623cebf9d48893329ef035278969fa3bbf75b697e"}, + {file = "coverage-7.4.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:29f3abe810930311c0b5d1a7140f6395369c3db1be68345638c33eec07535105"}, + {file = "coverage-7.4.0-cp38-cp38-win32.whl", hash = "sha256:5040148f4ec43644702e7b16ca864c5314ccb8ee0751ef617d49aa0e2d6bf4f2"}, + {file = "coverage-7.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:9864463c1c2f9cb3b5db2cf1ff475eed2f0b4285c2aaf4d357b69959941aa555"}, + {file = "coverage-7.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:936d38794044b26c99d3dd004d8af0035ac535b92090f7f2bb5aa9c8e2f5cd42"}, + {file = "coverage-7.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:799c8f873794a08cdf216aa5d0531c6a3747793b70c53f70e98259720a6fe2d7"}, + {file = "coverage-7.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e7defbb9737274023e2d7af02cac77043c86ce88a907c58f42b580a97d5bcca9"}, + {file = "coverage-7.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a1526d265743fb49363974b7aa8d5899ff64ee07df47dd8d3e37dcc0818f09ed"}, + {file = "coverage-7.4.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf635a52fc1ea401baf88843ae8708591aa4adff875e5c23220de43b1ccf575c"}, + {file = "coverage-7.4.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:756ded44f47f330666843b5781be126ab57bb57c22adbb07d83f6b519783b870"}, + {file = "coverage-7.4.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:0eb3c2f32dabe3a4aaf6441dde94f35687224dfd7eb2a7f47f3fd9428e421058"}, + {file = "coverage-7.4.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bfd5db349d15c08311702611f3dccbef4b4e2ec148fcc636cf8739519b4a5c0f"}, + {file = "coverage-7.4.0-cp39-cp39-win32.whl", hash = "sha256:53d7d9158ee03956e0eadac38dfa1ec8068431ef8058fe6447043db1fb40d932"}, + {file = "coverage-7.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:cfd2a8b6b0d8e66e944d47cdec2f47c48fef2ba2f2dff5a9a75757f64172857e"}, + {file = "coverage-7.4.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:c530833afc4707fe48524a44844493f36d8727f04dcce91fb978c414a8556cc6"}, + {file = "coverage-7.4.0.tar.gz", hash = "sha256:707c0f58cb1712b8809ece32b68996ee1e609f71bd14615bd8f87a1293cb610e"}, ] [[package]] @@ -420,6 +613,32 @@ files = [ {file = "Cython-3.0.5.tar.gz", hash = "sha256:39318348db488a2f24e7c84e08bdc82f2624853c0fea8b475ea0b70b27176492"}, ] +[[package]] +name = "debugpy" +version = "1.8.0" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +files = [ + {file = "debugpy-1.8.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7fb95ca78f7ac43393cd0e0f2b6deda438ec7c5e47fa5d38553340897d2fbdfb"}, + {file = "debugpy-1.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef9ab7df0b9a42ed9c878afd3eaaff471fce3fa73df96022e1f5c9f8f8c87ada"}, + {file = "debugpy-1.8.0-cp310-cp310-win32.whl", hash = "sha256:a8b7a2fd27cd9f3553ac112f356ad4ca93338feadd8910277aff71ab24d8775f"}, + {file = "debugpy-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:5d9de202f5d42e62f932507ee8b21e30d49aae7e46d5b1dd5c908db1d7068637"}, + {file = "debugpy-1.8.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:ef54404365fae8d45cf450d0544ee40cefbcb9cb85ea7afe89a963c27028261e"}, + {file = "debugpy-1.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60009b132c91951354f54363f8ebdf7457aeb150e84abba5ae251b8e9f29a8a6"}, + {file = "debugpy-1.8.0-cp311-cp311-win32.whl", hash = "sha256:8cd0197141eb9e8a4566794550cfdcdb8b3db0818bdf8c49a8e8f8053e56e38b"}, + {file = "debugpy-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:a64093656c4c64dc6a438e11d59369875d200bd5abb8f9b26c1f5f723622e153"}, + {file = "debugpy-1.8.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:b05a6b503ed520ad58c8dc682749113d2fd9f41ffd45daec16e558ca884008cd"}, + {file = "debugpy-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c6fb41c98ec51dd010d7ed650accfd07a87fe5e93eca9d5f584d0578f28f35f"}, + {file = "debugpy-1.8.0-cp38-cp38-win32.whl", hash = "sha256:46ab6780159eeabb43c1495d9c84cf85d62975e48b6ec21ee10c95767c0590aa"}, + {file = "debugpy-1.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:bdc5ef99d14b9c0fcb35351b4fbfc06ac0ee576aeab6b2511702e5a648a2e595"}, + {file = "debugpy-1.8.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:61eab4a4c8b6125d41a34bad4e5fe3d2cc145caecd63c3fe953be4cc53e65bf8"}, + {file = "debugpy-1.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:125b9a637e013f9faac0a3d6a82bd17c8b5d2c875fb6b7e2772c5aba6d082332"}, + {file = "debugpy-1.8.0-cp39-cp39-win32.whl", hash = "sha256:57161629133113c97b387382045649a2b985a348f0c9366e22217c87b68b73c6"}, + {file = "debugpy-1.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:e3412f9faa9ade82aa64a50b602544efcba848c91384e9f93497a458767e6926"}, + {file = "debugpy-1.8.0-py2.py3-none-any.whl", hash = "sha256:9c9b0ac1ce2a42888199df1a1906e45e6f3c9555497643a85e0bf2406e3ffbc4"}, + {file = "debugpy-1.8.0.zip", hash = "sha256:12af2c55b419521e33d5fb21bd022df0b5eb267c3e178f1d374a63a2a6bdccd0"}, +] + [[package]] name = "decorator" version = "5.1.1" @@ -431,16 +650,13 @@ files = [ ] [[package]] -name = "deprecated" -version = "1.2.14" -requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -summary = "Python @deprecated decorator to deprecate old python classes, functions or methods." -dependencies = [ - "wrapt<2,>=1.10", -] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" files = [ - {file = "Deprecated-1.2.14-py2.py3-none-any.whl", hash = "sha256:6fac8b097794a90302bdbb17b9b815e732d3c4720583ff1b198499d78470466c"}, - {file = "Deprecated-1.2.14.tar.gz", hash = "sha256:e5323eb936458dccc2582dc6f9c322c852a775a27065ff2b0c4970b9d53d01b3"}, + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, ] [[package]] @@ -492,6 +708,15 @@ files = [ {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, ] +[[package]] +name = "fastjsonschema" +version = "2.19.1" +summary = "Fastest Python implementation of JSON schema" +files = [ + {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, + {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, +] + [[package]] name = "filelock" version = "3.13.1" @@ -504,7 +729,7 @@ files = [ [[package]] name = "fluxcomp" -version = "0.1.2" +version = "0.1.4" requires_python = "<3.12,>=3.8" summary = "(ensator) provides numpy and pandas compatible implemenntations of cosmic ray flux models as well as calculation for simulation weights." dependencies = [ @@ -514,8 +739,8 @@ dependencies = [ "scipy<2.0.0,>=1.10.1", ] files = [ - {file = "fluxcomp-0.1.2-py3-none-any.whl", hash = "sha256:cea1bdb968af33ebd4f83f294b579bdeac1864ba0ea7ae3469330f53e4e28b0e"}, - {file = "fluxcomp-0.1.2.tar.gz", hash = "sha256:97860c4ba32b8abe62f58456387dd3e191da0ec38f9c76f79024e43abd8a03f1"}, + {file = "fluxcomp-0.1.4-py3-none-any.whl", hash = "sha256:8f452c5c51a696fcedab2460a6566aa280e1801acfb6948d337f385f536151d8"}, + {file = "fluxcomp-0.1.4.tar.gz", hash = "sha256:bcc872684b6209b8bad8e671760d0a983baa4ca9b6d748eec2bcf50c309f910a"}, ] [[package]] @@ -560,6 +785,16 @@ files = [ {file = "fonttools-4.44.0.tar.gz", hash = "sha256:4e90dd81b6e0d97ebfe52c0d12a17a9ef7f305d6bfbb93081265057d6092f252"}, ] +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +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 = "hepunits" version = "2.3.2" @@ -636,6 +871,31 @@ files = [ {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] +[[package]] +name = "ipykernel" +version = "6.28.0" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.28.0-py3-none-any.whl", hash = "sha256:c6e9a9c63a7f4095c0a22a79f765f079f9ec7be4f2430a898ddea889e8665661"}, + {file = "ipykernel-6.28.0.tar.gz", hash = "sha256:69c11403d26de69df02225916f916b37ea4b9af417da0a8c827f84328d88e5f3"}, +] + [[package]] name = "ipython" version = "8.12.3" @@ -661,6 +921,19 @@ files = [ {file = "ipython-8.12.3.tar.gz", hash = "sha256:3910c4b54543c2ad73d06579aa771041b7d5707b033bd488669b4cf544e3b363"}, ] +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + [[package]] name = "jedi" version = "0.19.1" @@ -687,6 +960,246 @@ files = [ {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"}, ] +[[package]] +name = "json5" +version = "0.9.14" +summary = "A Python implementation of the JSON5 data format." +files = [ + {file = "json5-0.9.14-py2.py3-none-any.whl", hash = "sha256:740c7f1b9e584a468dbb2939d8d458db3427f2c93ae2139d05f47e453eae964f"}, + {file = "json5-0.9.14.tar.gz", hash = "sha256:9ed66c3a6ca3510a976a9ef9b8c0787de24802724ab1860bc0153c7fdd589b02"}, +] + +[[package]] +name = "jsonpointer" +version = "2.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +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.20.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.20.0-py3-none-any.whl", hash = "sha256:ed6231f0429ecf966f5bc8dfef245998220549cbbcf140f913b7464c52c3b6b3"}, + {file = "jsonschema-4.20.0.tar.gz", hash = "sha256:4f614fd46d8d61258610998997743ec5492a648b33cf478c1ddc23ed4598a5fa"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +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]] +name = "jsonschema" +version = "4.20.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.20.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=1.11", +] +files = [ + {file = "jsonschema-4.20.0-py3-none-any.whl", hash = "sha256:ed6231f0429ecf966f5bc8dfef245998220549cbbcf140f913b7464c52c3b6b3"}, + {file = "jsonschema-4.20.0.tar.gz", hash = "sha256:4f614fd46d8d61258610998997743ec5492a648b33cf478c1ddc23ed4598a5fa"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.0" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.0-py3-none-any.whl", hash = "sha256:909c474dbe62582ae62b758bca86d6518c85234bdee2d908c778db6d72f39d99"}, + {file = "jupyter_client-8.6.0.tar.gz", hash = "sha256:0642244bb83b4764ae60d07e010e15f0e2d275ec4e918a8f7b80fbbef3ca60c7"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.1" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.1-py3-none-any.whl", hash = "sha256:c65c82126453a723a2804aa52409930434598fd9d35091d63dfb919d2b765bb7"}, + {file = "jupyter_core-5.7.1.tar.gz", hash = "sha256:de61a9d7fc71240f688b2fb5ab659fbb56979458dc66a71decd098e03c79e218"}, +] + +[[package]] +name = "jupyter-events" +version = "0.9.0" +requires_python = ">=3.8" +summary = "Jupyter Event System library" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.9.0-py3-none-any.whl", hash = "sha256:d853b3c10273ff9bc8bb8b30076d65e2c9685579db736873de6c2232dde148bf"}, + {file = "jupyter_events-0.9.0.tar.gz", hash = "sha256:81ad2e4bc710881ec274d31c6c50669d71bbaa5dd9d01e600b56faa85700d399"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.1" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.1.tar.gz", hash = "sha256:b17fab6d70fe83c8896b0cff59237640038247c196056b43684a0902b6a9e0fb"}, + {file = "jupyter_lsp-2.2.1-py3-none-any.whl", hash = "sha256:17a689910c5e4ae5e7d334b02f31d08ffbe98108f6f658fb05e4304b4345368b"}, +] + +[[package]] +name = "jupyter-server" +version = "2.12.2" +requires_python = ">=3.8" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi", + "jinja2", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.9.0", + "jupyter-server-terminals", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides", + "packaging", + "prometheus-client", + "pywinpty; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client", +] +files = [ + {file = "jupyter_server-2.12.2-py3-none-any.whl", hash = "sha256:abcfa33f98a959f908c8733aa2d9fa0101d26941cbd49b148f4cef4d3046fc61"}, + {file = "jupyter_server-2.12.2.tar.gz", hash = "sha256:5eae86be15224b5375cdec0c3542ce72ff20f7a25297a2a8166a250bb455a519"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.1" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.1-py3-none-any.whl", hash = "sha256:5e63e947ddd97bb2832db5ef837a258d9ccd4192cd608c1270850ad947ae5dd7"}, + {file = "jupyter_server_terminals-0.5.1.tar.gz", hash = "sha256:16d3be9cf48be6a1f943f3a6c93c033be259cf4779184c66421709cf63dccfea"}, +] + +[[package]] +name = "jupyterlab" +version = "4.0.10" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +dependencies = [ + "async-lru>=1.0.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.19.0", + "notebook-shim>=0.2", + "packaging", + "tomli; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.0.10-py3-none-any.whl", hash = "sha256:fe010ad9e37017488b468632ef2ead255fc7c671c5b64d9ca13e1f7b7e665c37"}, + {file = "jupyterlab-4.0.10.tar.gz", hash = "sha256:46177eb8ede70dc73be922ac99f8ef943bdc2dfbc6a31b353c4bde848a35dee1"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +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.25.2" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.25.2-py3-none-any.whl", hash = "sha256:5b1798c9cc6a44f65c757de9f97fc06fc3d42535afbf47d2ace5e964ab447aaf"}, + {file = "jupyterlab_server-2.25.2.tar.gz", hash = "sha256:bd0ec7a99ebcedc8bcff939ef86e52c378e44c2707e053fcd81d046ce979ee63"}, +] + [[package]] name = "kiwisolver" version = "1.4.5" @@ -772,16 +1285,16 @@ files = [ ] [[package]] -name = "m2r2" -version = "0.3.2" -summary = "Markdown and reStructuredText in a single file." +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" dependencies = [ - "docutils", - "mistune==0.8.4", + "mdurl~=0.1", ] files = [ - {file = "m2r2-0.3.2-py3-none-any.whl", hash = "sha256:d3684086b61b4bebe2307f15189495360f05a123c9bda2a66462649b7ca236aa"}, - {file = "m2r2-0.3.2.tar.gz", hash = "sha256:ccd95b052dcd1ac7442ecb3111262b2001c10e4119b459c34c93ac7a5c2c7868"}, + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, ] [[package]] @@ -835,7 +1348,7 @@ files = [ [[package]] name = "matplotlib" -version = "3.7.3" +version = "3.7.4" requires_python = ">=3.8" summary = "Python plotting package" dependencies = [ @@ -851,47 +1364,47 @@ dependencies = [ "python-dateutil>=2.7", ] files = [ - {file = "matplotlib-3.7.3-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:085c33b27561d9c04386789d5aa5eb4a932ddef43cfcdd0e01735f9a6e85ce0c"}, - {file = "matplotlib-3.7.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c568e80e1c17f68a727f30f591926751b97b98314d8e59804f54f86ae6fa6a22"}, - {file = "matplotlib-3.7.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7baf98c5ad59c5c4743ea884bb025cbffa52dacdfdac0da3e6021a285a90377e"}, - {file = "matplotlib-3.7.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:236024f582e40dac39bca592258888b38ae47a9fed7b8de652d68d3d02d47d2b"}, - {file = "matplotlib-3.7.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12b4f6795efea037ce2d41e7c417ad8bd02d5719c6ad4a8450a0708f4a1cfb89"}, - {file = "matplotlib-3.7.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b2136cc6c5415b78977e0e8c608647d597204b05b1d9089ccf513c7d913733"}, - {file = "matplotlib-3.7.3-cp310-cp310-win32.whl", hash = "sha256:122dcbf9be0086e2a95d9e5e0632dbf3bd5b65eaa68c369363310a6c87753059"}, - {file = "matplotlib-3.7.3-cp310-cp310-win_amd64.whl", hash = "sha256:4aab27d9e33293389e3c1d7c881d414a72bdfda0fedc3a6bf46c6fa88d9b8015"}, - {file = "matplotlib-3.7.3-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:d5adc743de91e8e0b13df60deb1b1c285b8effea3d66223afceb14b63c9b05de"}, - {file = "matplotlib-3.7.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:55de4cf7cd0071b8ebf203981b53ab64f988a0a1f897a2dff300a1124e8bcd8b"}, - {file = "matplotlib-3.7.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ac03377fd908aaee2312d0b11735753e907adb6f4d1d102de5e2425249693f6c"}, - {file = "matplotlib-3.7.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:755bafc10a46918ce9a39980009b54b02dd249594e5adf52f9c56acfddb5d0b7"}, - {file = "matplotlib-3.7.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a6094c6f8e8d18db631754df4fe9a34dec3caf074f6869a7db09f18f9b1d6b2"}, - {file = "matplotlib-3.7.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:272dba2f1b107790ed78ebf5385b8d14b27ad9e90419de340364b49fe549a993"}, - {file = "matplotlib-3.7.3-cp311-cp311-win32.whl", hash = "sha256:591c123bed1cb4b9996fb60b41a6d89c2ec4943244540776c5f1283fb6960a53"}, - {file = "matplotlib-3.7.3-cp311-cp311-win_amd64.whl", hash = "sha256:3bf3a178c6504694cee8b88b353df0051583f2f6f8faa146f67115c27c856881"}, - {file = "matplotlib-3.7.3-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:259999c05285cb993d7f2a419cea547863fa215379eda81f7254c9e932963729"}, - {file = "matplotlib-3.7.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:3f4e7fd5a6157e1d018ce2166ec8e531a481dd4a36f035b5c23edfe05a25419a"}, - {file = "matplotlib-3.7.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:faa3d12d8811d08d14080a8b7b9caea9a457dc495350166b56df0db4b9909ef5"}, - {file = "matplotlib-3.7.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:336e88900c11441e458da01c8414fc57e04e17f9d3bb94958a76faa2652bcf6b"}, - {file = "matplotlib-3.7.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:12f4c0dd8aa280d796c8772ea8265a14f11a04319baa3a16daa5556065e8baea"}, - {file = "matplotlib-3.7.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1990955b11e7918d256cf3b956b10997f405b7917a3f1c7d8e69c1d15c7b1930"}, - {file = "matplotlib-3.7.3-cp38-cp38-win32.whl", hash = "sha256:e78707b751260b42b721507ad7aa60fe4026d7f51c74cca6b9cd8b123ebb633a"}, - {file = "matplotlib-3.7.3-cp38-cp38-win_amd64.whl", hash = "sha256:e594ee43c59ea39ca5c6244667cac9d017a3527febc31f5532ad9135cf7469ec"}, - {file = "matplotlib-3.7.3-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:6eaa1cf0e94c936a26b78f6d756c5fbc12e0a58c8a68b7248a2a31456ce4e234"}, - {file = "matplotlib-3.7.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:0a97af9d22e8ebedc9f00b043d9bbd29a375e9e10b656982012dded44c10fd77"}, - {file = "matplotlib-3.7.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1f9c6c16597af660433ab330b59ee2934b832ee1fabcaf5cbde7b2add840f31e"}, - {file = "matplotlib-3.7.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7240259b4b9cbc62381f6378cff4d57af539162a18e832c1e48042fabc40b6b"}, - {file = "matplotlib-3.7.3-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:747c6191d2e88ae854809e69aa358dbf852ff1a5738401b85c1cc9012309897a"}, - {file = "matplotlib-3.7.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec726b08a5275d827aa91bb951e68234a4423adb91cf65bc0fcdc0f2777663f7"}, - {file = "matplotlib-3.7.3-cp39-cp39-win32.whl", hash = "sha256:40e3b9b450c6534f07278310c4e34caff41c2a42377e4b9d47b0f8d3ac1083a2"}, - {file = "matplotlib-3.7.3-cp39-cp39-win_amd64.whl", hash = "sha256:dfc118642903a23e309b1da32886bb39a4314147d013e820c86b5fb4cb2e36d0"}, - {file = "matplotlib-3.7.3-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:165c8082bf8fc0360c24aa4724a22eaadbfd8c28bf1ccf7e94d685cad48261e4"}, - {file = "matplotlib-3.7.3-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ebd8470cc2a3594746ff0513aecbfa2c55ff6f58e6cef2efb1a54eb87c88ffa2"}, - {file = "matplotlib-3.7.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7153453669c9672b52095119fd21dd032d19225d48413a2871519b17db4b0fde"}, - {file = "matplotlib-3.7.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:498a08267dc69dd8f24c4b5d7423fa584d7ce0027ba71f7881df05fc09b89bb7"}, - {file = "matplotlib-3.7.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:d48999c4b19b5a0c058c9cd828ff6fc7748390679f6cf9a2ad653a3e802c87d3"}, - {file = "matplotlib-3.7.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22d65d18b4ee8070a5fea5761d59293f1f9e2fac37ec9ce090463b0e629432fd"}, - {file = "matplotlib-3.7.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c40cde976c36693cc0767e27cf5f443f91c23520060bd9496678364adfafe9c"}, - {file = "matplotlib-3.7.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:39018a2b17592448fbfdf4b8352955e6c3905359939791d4ff429296494d1a0c"}, - {file = "matplotlib-3.7.3.tar.gz", hash = "sha256:f09b3dd6bdeb588de91f853bbb2d6f0ff8ab693485b0c49035eaa510cb4f142e"}, + {file = "matplotlib-3.7.4-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:b71079239bd866bf56df023e5146de159cb0c7294e508830901f4d79e2d89385"}, + {file = "matplotlib-3.7.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:bf91a42f6274a64cb41189120b620c02e574535ff6671fa836cade7701b06fbd"}, + {file = "matplotlib-3.7.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f757e8b42841d6add0cb69b42497667f0d25a404dcd50bd923ec9904e38414c4"}, + {file = "matplotlib-3.7.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4dfee00aa4bd291e08bb9461831c26ce0da85ca9781bb8794f2025c6e925281"}, + {file = "matplotlib-3.7.4-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3640f33632beb3993b698b1be9d1c262b742761d6101f3c27b87b2185d25c875"}, + {file = "matplotlib-3.7.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff539c4a17ecdf076ed808ee271ffae4a30dcb7e157b99ccae2c837262c07db6"}, + {file = "matplotlib-3.7.4-cp310-cp310-win32.whl", hash = "sha256:24b8f28af3e766195c09b780b15aa9f6710192b415ae7866b9c03dee7ec86370"}, + {file = "matplotlib-3.7.4-cp310-cp310-win_amd64.whl", hash = "sha256:3fa193286712c3b6c3cfa5fe8a6bb563f8c52cc750006c782296e0807ce5e799"}, + {file = "matplotlib-3.7.4-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:b167f54cb4654b210c9624ec7b54e2b3b8de68c93a14668937e7e53df60770ec"}, + {file = "matplotlib-3.7.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7dfe6821f1944cb35603ff22e21510941bbcce7ccf96095beffaac890d39ce77"}, + {file = "matplotlib-3.7.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3c557d9165320dff3c5f2bb99bfa0b6813d3e626423ff71c40d6bc23b83c3339"}, + {file = "matplotlib-3.7.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08372696b3bb45c563472a552a705bfa0942f0a8ffe084db8a4e8f9153fbdf9d"}, + {file = "matplotlib-3.7.4-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:81e1a7ac818000e8ac3ca696c3fdc501bc2d3adc89005e7b4e22ee5e9d51de98"}, + {file = "matplotlib-3.7.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:390920a3949906bc4b0216198d378f2a640c36c622e3584dd0c79a7c59ae9f50"}, + {file = "matplotlib-3.7.4-cp311-cp311-win32.whl", hash = "sha256:62e094d8da26294634da9e7f1856beee3978752b1b530c8e1763d2faed60cc10"}, + {file = "matplotlib-3.7.4-cp311-cp311-win_amd64.whl", hash = "sha256:f8fc2df756105784e650605e024d36dc2d048d68e5c1b26df97ee25d1bd41f9f"}, + {file = "matplotlib-3.7.4-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:ce163be048613b9d1962273708cc97e09ca05d37312e670d166cf332b80bbaff"}, + {file = "matplotlib-3.7.4-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:e680f49bb8052ba3b2698e370155d2b4afb49f9af1cc611a26579d5981e2852a"}, + {file = "matplotlib-3.7.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0604880e4327114054199108b7390f987f4f40ee5ce728985836889e11a780ba"}, + {file = "matplotlib-3.7.4-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1e6abcde6fc52475f9d6a12b9f1792aee171ce7818ef6df5d61cb0b82816e6e8"}, + {file = "matplotlib-3.7.4-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f59a70e2ec3212033ef6633ed07682da03f5249379722512a3a2a26a7d9a738e"}, + {file = "matplotlib-3.7.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a9981b2a2dd9da06eca4ab5855d09b54b8ce7377c3e0e3957767b83219d652d"}, + {file = "matplotlib-3.7.4-cp38-cp38-win32.whl", hash = "sha256:83859ac26839660ecd164ee8311272074250b915ac300f9b2eccc84410f8953b"}, + {file = "matplotlib-3.7.4-cp38-cp38-win_amd64.whl", hash = "sha256:7a7709796ac59fe8debde68272388be6ed449c8971362eb5b60d280eac8dadde"}, + {file = "matplotlib-3.7.4-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:b1d70bc1ea1bf110bec64f4578de3e14947909a8887df4c1fd44492eca487955"}, + {file = "matplotlib-3.7.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c83f49e795a5de6c168876eea723f5b88355202f9603c55977f5356213aa8280"}, + {file = "matplotlib-3.7.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5c9133f230945fe10652eb33e43642e933896194ef6a4f8d5e79bb722bdb2000"}, + {file = "matplotlib-3.7.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:798ff59022eeb276380ce9a73ba35d13c3d1499ab9b73d194fd07f1b0a41c304"}, + {file = "matplotlib-3.7.4-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1707b20b25e90538c2ce8d4409e30f0ef1df4017cc65ad0439633492a973635b"}, + {file = "matplotlib-3.7.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e6227ca8492baeef873cdd8e169a318efb5c3a25ce94e69727e7f964995b0b1"}, + {file = "matplotlib-3.7.4-cp39-cp39-win32.whl", hash = "sha256:5661c8639aded7d1bbf781373a359011cb1dd09199dee49043e9e68dd16f07ba"}, + {file = "matplotlib-3.7.4-cp39-cp39-win_amd64.whl", hash = "sha256:55eec941a4743f0bd3e5b8ee180e36b7ea8e62f867bf2613937c9f01b9ac06a2"}, + {file = "matplotlib-3.7.4-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ab16868714e5cc90ec8f7ff5d83d23bcd6559224d8e9cb5227c9f58748889fe8"}, + {file = "matplotlib-3.7.4-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c698b33f9a3f0b127a8e614c8fb4087563bb3caa9c9d95298722fa2400cdd3f"}, + {file = "matplotlib-3.7.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be3493bbcb4d255cb71de1f9050ac71682fce21a56089eadbcc8e21784cb12ee"}, + {file = "matplotlib-3.7.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:f8c725d1dd2901b2e7ec6cd64165e00da2978cc23d4143cb9ef745bec88e6b04"}, + {file = "matplotlib-3.7.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:286332f8f45f8ffde2d2119b9fdd42153dccd5025fa9f451b4a3b5c086e26da5"}, + {file = "matplotlib-3.7.4-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:116ef0b43aa00ff69260b4cce39c571e4b8c6f893795b708303fa27d9b9d7548"}, + {file = "matplotlib-3.7.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c90590d4b46458677d80bc3218f3f1ac11fc122baa9134e0cb5b3e8fc3714052"}, + {file = "matplotlib-3.7.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:de7c07069687be64fd9d119da3122ba13a8d399eccd3f844815f0dc78a870b2c"}, + {file = "matplotlib-3.7.4.tar.gz", hash = "sha256:7cd4fef8187d1dd0d9dcfdbaa06ac326d396fb8c71c647129f0bf56835d77026"}, ] [[package]] @@ -907,13 +1420,37 @@ files = [ {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"}, ] +[[package]] +name = "mdit-py-plugins" +version = "0.4.0" +requires_python = ">=3.8" +summary = "Collection of plugins for markdown-it-py" +dependencies = [ + "markdown-it-py<4.0.0,>=1.0.0", +] +files = [ + {file = "mdit_py_plugins-0.4.0-py3-none-any.whl", hash = "sha256:b51b3bb70691f57f974e257e367107857a93b36f322a9e6d44ca5bf28ec2def9"}, + {file = "mdit_py_plugins-0.4.0.tar.gz", hash = "sha256:d8ab27e9aed6c38aa716819fedfde15ca275715955f8a185a8e1cf90fb1d2c1b"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + [[package]] name = "mistune" -version = "0.8.4" -summary = "The fastest markdown parser in pure Python" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" files = [ - {file = "mistune-0.8.4-py2.py3-none-any.whl", hash = "sha256:88a1051873018da288eee8538d476dffe1262495144b33ecb586c4ab266bb8d4"}, - {file = "mistune-0.8.4.tar.gz", hash = "sha256:59a3429db53c50b5c6bcc8a07f8848cb00d7dc8bdb431a4ab41920d201d4756e"}, + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, ] [[package]] @@ -971,7 +1508,7 @@ files = [ [[package]] name = "mypy" -version = "1.6.1" +version = "1.8.0" requires_python = ">=3.8" summary = "Optional static typing for Python" dependencies = [ @@ -980,28 +1517,28 @@ dependencies = [ "typing-extensions>=4.1.0", ] files = [ - {file = "mypy-1.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e5012e5cc2ac628177eaac0e83d622b2dd499e28253d4107a08ecc59ede3fc2c"}, - {file = "mypy-1.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d8fbb68711905f8912e5af474ca8b78d077447d8f3918997fecbf26943ff3cbb"}, - {file = "mypy-1.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a1ad938fee7d2d96ca666c77b7c494c3c5bd88dff792220e1afbebb2925b5e"}, - {file = "mypy-1.6.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b96ae2c1279d1065413965c607712006205a9ac541895004a1e0d4f281f2ff9f"}, - {file = "mypy-1.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:40b1844d2e8b232ed92e50a4bd11c48d2daa351f9deee6c194b83bf03e418b0c"}, - {file = "mypy-1.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:81af8adaa5e3099469e7623436881eff6b3b06db5ef75e6f5b6d4871263547e5"}, - {file = "mypy-1.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8c223fa57cb154c7eab5156856c231c3f5eace1e0bed9b32a24696b7ba3c3245"}, - {file = "mypy-1.6.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8032e00ce71c3ceb93eeba63963b864bf635a18f6c0c12da6c13c450eedb183"}, - {file = "mypy-1.6.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4c46b51de523817a0045b150ed11b56f9fff55f12b9edd0f3ed35b15a2809de0"}, - {file = "mypy-1.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:19f905bcfd9e167159b3d63ecd8cb5e696151c3e59a1742e79bc3bcb540c42c7"}, - {file = "mypy-1.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:41697773aa0bf53ff917aa077e2cde7aa50254f28750f9b88884acea38a16169"}, - {file = "mypy-1.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7274b0c57737bd3476d2229c6389b2ec9eefeb090bbaf77777e9d6b1b5a9d143"}, - {file = "mypy-1.6.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbaf4662e498c8c2e352da5f5bca5ab29d378895fa2d980630656178bd607c46"}, - {file = "mypy-1.6.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bb8ccb4724f7d8601938571bf3f24da0da791fe2db7be3d9e79849cb64e0ae85"}, - {file = "mypy-1.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:68351911e85145f582b5aa6cd9ad666c8958bcae897a1bfda8f4940472463c45"}, - {file = "mypy-1.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:49ae115da099dcc0922a7a895c1eec82c1518109ea5c162ed50e3b3594c71208"}, - {file = "mypy-1.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8b27958f8c76bed8edaa63da0739d76e4e9ad4ed325c814f9b3851425582a3cd"}, - {file = "mypy-1.6.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:925cd6a3b7b55dfba252b7c4561892311c5358c6b5a601847015a1ad4eb7d332"}, - {file = "mypy-1.6.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8f57e6b6927a49550da3d122f0cb983d400f843a8a82e65b3b380d3d7259468f"}, - {file = "mypy-1.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:a43ef1c8ddfdb9575691720b6352761f3f53d85f1b57d7745701041053deff30"}, - {file = "mypy-1.6.1-py3-none-any.whl", hash = "sha256:4cbe68ef919c28ea561165206a2dcb68591c50f3bcf777932323bc208d949cf1"}, - {file = "mypy-1.6.1.tar.gz", hash = "sha256:4d01c00d09a0be62a4ca3f933e315455bde83f37f892ba4b08ce92f3cf44bcc1"}, + {file = "mypy-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:485a8942f671120f76afffff70f259e1cd0f0cfe08f81c05d8816d958d4577d3"}, + {file = "mypy-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:df9824ac11deaf007443e7ed2a4a26bebff98d2bc43c6da21b2b64185da011c4"}, + {file = "mypy-1.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2afecd6354bbfb6e0160f4e4ad9ba6e4e003b767dd80d85516e71f2e955ab50d"}, + {file = "mypy-1.8.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8963b83d53ee733a6e4196954502b33567ad07dfd74851f32be18eb932fb1cb9"}, + {file = "mypy-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:e46f44b54ebddbeedbd3d5b289a893219065ef805d95094d16a0af6630f5d410"}, + {file = "mypy-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:855fe27b80375e5c5878492f0729540db47b186509c98dae341254c8f45f42ae"}, + {file = "mypy-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4c886c6cce2d070bd7df4ec4a05a13ee20c0aa60cb587e8d1265b6c03cf91da3"}, + {file = "mypy-1.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d19c413b3c07cbecf1f991e2221746b0d2a9410b59cb3f4fb9557f0365a1a817"}, + {file = "mypy-1.8.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9261ed810972061388918c83c3f5cd46079d875026ba97380f3e3978a72f503d"}, + {file = "mypy-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:51720c776d148bad2372ca21ca29256ed483aa9a4cdefefcef49006dff2a6835"}, + {file = "mypy-1.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:028cf9f2cae89e202d7b6593cd98db6759379f17a319b5faf4f9978d7084cdc6"}, + {file = "mypy-1.8.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4e6d97288757e1ddba10dd9549ac27982e3e74a49d8d0179fc14d4365c7add66"}, + {file = "mypy-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f1478736fcebb90f97e40aff11a5f253af890c845ee0c850fe80aa060a267c6"}, + {file = "mypy-1.8.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:42419861b43e6962a649068a61f4a4839205a3ef525b858377a960b9e2de6e0d"}, + {file = "mypy-1.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:2b5b6c721bd4aabaadead3a5e6fa85c11c6c795e0c81a7215776ef8afc66de02"}, + {file = "mypy-1.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5c1538c38584029352878a0466f03a8ee7547d7bd9f641f57a0f3017a7c905b8"}, + {file = "mypy-1.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4ef4be7baf08a203170f29e89d79064463b7fc7a0908b9d0d5114e8009c3a259"}, + {file = "mypy-1.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7178def594014aa6c35a8ff411cf37d682f428b3b5617ca79029d8ae72f5402b"}, + {file = "mypy-1.8.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ab3c84fa13c04aeeeabb2a7f67a25ef5d77ac9d6486ff33ded762ef353aa5592"}, + {file = "mypy-1.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:99b00bc72855812a60d253420d8a2eae839b0afa4938f09f4d2aa9bb4654263a"}, + {file = "mypy-1.8.0-py3-none-any.whl", hash = "sha256:538fd81bb5e430cc1381a443971c0475582ff9f434c16cd46d2c66763ce85d9d"}, + {file = "mypy-1.8.0.tar.gz", hash = "sha256:6ff8b244d7085a0b425b56d327b480c3b29cafbd2eff27316a004f9a7391ae07"}, ] [[package]] @@ -1014,6 +1551,112 @@ files = [ {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, ] +[[package]] +name = "myst-parser" +version = "2.0.0" +requires_python = ">=3.8" +summary = "An extended [CommonMark](https://spec.commonmark.org/) compliant parser," +dependencies = [ + "docutils<0.21,>=0.16", + "jinja2", + "markdown-it-py~=3.0", + "mdit-py-plugins~=0.4", + "pyyaml", + "sphinx<8,>=6", +] +files = [ + {file = "myst_parser-2.0.0-py3-none-any.whl", hash = "sha256:7c36344ae39c8e740dad7fdabf5aa6fc4897a813083c6cc9990044eb93656b14"}, + {file = "myst_parser-2.0.0.tar.gz", hash = "sha256:ea929a67a6a0b1683cdbe19b8d2e724cd7643f8aa3e7bb18dd65beac3483bead"}, +] + +[[package]] +name = "nbclient" +version = "0.9.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.9.0-py3-none-any.whl", hash = "sha256:a3a1ddfb34d4a9d17fc744d655962714a866639acd30130e9be84191cd97cd15"}, + {file = "nbclient-0.9.0.tar.gz", hash = "sha256:4b28c207877cf33ef3a9838cdc7a54c5ceff981194a82eac59d558f05487295e"}, +] + +[[package]] +name = "nbconvert" +version = "7.14.0" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks" +dependencies = [ + "beautifulsoup4", + "bleach!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "tinycss2", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.14.0-py3-none-any.whl", hash = "sha256:483dde47facdaa4875903d651305ad53cd76e2255ae3c61efe412a95f2d22a24"}, + {file = "nbconvert-7.14.0.tar.gz", hash = "sha256:92b9a44b63e5a7fb4f6fa0ef41261e35c16925046ccd1c04a5c8099bf100476e"}, +] + +[[package]] +name = "nbformat" +version = "5.9.2" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +dependencies = [ + "fastjsonschema", + "jsonschema>=2.6", + "jupyter-core", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.9.2-py3-none-any.whl", hash = "sha256:1c5172d786a41b82bcfd0c23f9e6b6f072e8fb49c39250219e4acfff1efe89e9"}, + {file = "nbformat-5.9.2.tar.gz", hash = "sha256:5f98b5ba1997dff175e77e0c17d5c10a96eaed2cbd1de3533d1fc35d5e111192"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.3" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +dependencies = [ + "docutils", + "jinja2", + "nbconvert!=5.4", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.3-py3-none-any.whl", hash = "sha256:6e805e9627f4a358bd5720d5cbf8bf48853989c79af557afd91a5f22e163029f"}, + {file = "nbsphinx-0.9.3.tar.gz", hash = "sha256:ec339c8691b688f8676104a367a4b8cf3ea01fd089dc28d24dec22d563b11562"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.5.8" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +files = [ + {file = "nest_asyncio-1.5.8-py3-none-any.whl", hash = "sha256:accda7a339a70599cb08f9dd09a67e0c2ef8d8d6f4c07f96ab203f2ae254e48d"}, + {file = "nest_asyncio-1.5.8.tar.gz", hash = "sha256:25aa2ca0d2a5b5531956b9e273b45cf664cae2b145101d73b86b199978d48fdb"}, +] + [[package]] name = "nodeenv" version = "1.8.0" @@ -1027,6 +1670,36 @@ files = [ {file = "nodeenv-1.8.0.tar.gz", hash = "sha256:d51e0c37e64fbf47d017feac3145cdbb58836d7eee8c6f6d3b6880c5456227d2"}, ] +[[package]] +name = "notebook" +version = "7.0.6" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.22.1", + "jupyterlab<5,>=4.0.2", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.0.6-py3-none-any.whl", hash = "sha256:0fe8f67102fea3744fedf652e4c15339390902ca70c5a31c4f547fa23da697cc"}, + {file = "notebook-7.0.6.tar.gz", hash = "sha256:ec6113b06529019f7f287819af06c97a2baf7a95ac21a8f6e32192898e9f9a58"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.3" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.3-py3-none-any.whl", hash = "sha256:a83496a43341c1674b093bfcebf0fe8e74cbe7eda5fd2bbc56f8e39e1486c0c7"}, + {file = "notebook_shim-0.2.3.tar.gz", hash = "sha256:f69388ac283ae008cd506dda10d0288b09a017d822d5e8c7129a152cbd3ce7e9"}, +] + [[package]] name = "numexpr" version = "2.8.6" @@ -1099,6 +1772,16 @@ files = [ {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, ] +[[package]] +name = "overrides" +version = "7.4.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +files = [ + {file = "overrides-7.4.0-py3-none-any.whl", hash = "sha256:3ad24583f86d6d7a49049695efe9933e67ba62f0c7625d53c59fa832ce4b8b7d"}, + {file = "overrides-7.4.0.tar.gz", hash = "sha256:9502a3cca51f4fac40b5feca985b6703a5c1f6ad815588a7ca9e285b9dca6757"}, +] + [[package]] name = "packaging" version = "23.2" @@ -1150,6 +1833,16 @@ files = [ {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, ] +[[package]] +name = "pandocfilters" +version = "1.5.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +files = [ + {file = "pandocfilters-1.5.0-py2.py3-none-any.whl", hash = "sha256:33aae3f25fd1a026079f5d27bdd52496f0e0803b3469282162bafdcbdf6ef14f"}, + {file = "pandocfilters-1.5.0.tar.gz", hash = "sha256:0b679503337d233b4339a817bfc8c50064e2eff681314376a47cb582305a7a38"}, +] + [[package]] name = "parso" version = "0.8.3" @@ -1162,18 +1855,18 @@ files = [ [[package]] name = "particle" -version = "0.23.0" +version = "0.23.1" requires_python = ">=3.7" summary = "Extended PDG particle data and MC identification codes" dependencies = [ "attrs>=19.2", - "deprecated", "hepunits>=2.0.0", "importlib-resources>=2.0; python_version < \"3.9\"", + "typing-extensions>=4.5; python_version < \"3.13\"", ] files = [ - {file = "particle-0.23.0-py3-none-any.whl", hash = "sha256:d3734768b3dbcc40b3d6457266f87204ce61f6fdad0c8be2c0f6ced74208a46d"}, - {file = "particle-0.23.0.tar.gz", hash = "sha256:d810f8fc27deb8e7fd64174017d9607d50522249c0973a0008e580f93db11750"}, + {file = "particle-0.23.1-py3-none-any.whl", hash = "sha256:1c68a36f1c3640bd8e5d4f47fc026064aa28264dfd283121d1f784d55947f1b7"}, + {file = "particle-0.23.1.tar.gz", hash = "sha256:eee28b0e846bfea4dfd70e9ec5ffe3244613db08b6b6a9b773f55a4310752fab"}, ] [[package]] @@ -1260,6 +1953,16 @@ files = [ {file = "Pillow-10.1.0.tar.gz", hash = "sha256:e6bf8de6c36ed96c86ea3b6e1d5273c53f46ef518a062464cd7ef5dd2cf92e38"}, ] +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +requires_python = ">=3.6" +summary = "Resolve a name to an object." +files = [ + {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, + {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, +] + [[package]] name = "platformdirs" version = "3.11.0" @@ -1297,6 +2000,16 @@ files = [ {file = "pre_commit-3.5.0.tar.gz", hash = "sha256:5804465c675b659b0862f07907f96295d490822a450c4c40e747d0b1c6ebcb32"}, ] +[[package]] +name = "prometheus-client" +version = "0.19.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +files = [ + {file = "prometheus_client-0.19.0-py3-none-any.whl", hash = "sha256:c88b1e6ecf6b41cd8fb5731c7ae919bf66df6ec6fafa555cd6c0e16ca169ae92"}, + {file = "prometheus_client-0.19.0.tar.gz", hash = "sha256:4585b0d1223148c27a225b10dbec5ae9bc4c81a99a3fa80774fa6209935324e1"}, +] + [[package]] name = "prompt-toolkit" version = "3.0.39" @@ -1310,6 +2023,21 @@ files = [ {file = "prompt_toolkit-3.0.39.tar.gz", hash = "sha256:04505ade687dc26dc4284b1ad19a83be2f2afe83e7a828ace0c72f3a1df72aac"}, ] +[[package]] +name = "psutil" +version = "5.9.7" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +summary = "Cross-platform lib for process and system monitoring in Python." +files = [ + {file = "psutil-5.9.7-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ea36cc62e69a13ec52b2f625c27527f6e4479bca2b340b7a452af55b34fcbe2e"}, + {file = "psutil-5.9.7-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1132704b876e58d277168cd729d64750633d5ff0183acf5b3c986b8466cd0284"}, + {file = "psutil-5.9.7-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe8b7f07948f1304497ce4f4684881250cd859b16d06a1dc4d7941eeb6233bfe"}, + {file = "psutil-5.9.7-cp37-abi3-win32.whl", hash = "sha256:c727ca5a9b2dd5193b8644b9f0c883d54f1248310023b5ad3e92036c5e2ada68"}, + {file = "psutil-5.9.7-cp37-abi3-win_amd64.whl", hash = "sha256:f37f87e4d73b79e6c5e749440c3113b81d1ee7d26f21c19c47371ddea834f414"}, + {file = "psutil-5.9.7-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:032f4f2c909818c86cea4fe2cc407f1c0f0cde8e6c6d702b28b8ce0c0d143340"}, + {file = "psutil-5.9.7.tar.gz", hash = "sha256:3f02134e82cfb5d089fddf20bb2e03fd5cd52395321d1c8458a9e58500ff417c"}, +] + [[package]] name = "ptyprocess" version = "0.7.0" @@ -1337,6 +2065,36 @@ files = [ {file = "py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5"}, ] +[[package]] +name = "pycparser" +version = "2.21" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "C parser in Python" +files = [ + {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, + {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, +] + +[[package]] +name = "pydata-sphinx-theme" +version = "0.14.4" +requires_python = ">=3.8" +summary = "Bootstrap-based Sphinx theme from the PyData community" +dependencies = [ + "Babel", + "accessible-pygments", + "beautifulsoup4", + "docutils!=0.17.0", + "packaging", + "pygments>=2.7", + "sphinx>=5.0", + "typing-extensions", +] +files = [ + {file = "pydata_sphinx_theme-0.14.4-py3-none-any.whl", hash = "sha256:ac15201f4c2e2e7042b0cad8b30251433c1f92be762ddcefdb4ae68811d918d9"}, + {file = "pydata_sphinx_theme-0.14.4.tar.gz", hash = "sha256:f5d7a2cb7a98e35b9b49d3b02cec373ad28958c2ed5c9b1ffe6aff6c56e9de5b"}, +] + [[package]] name = "pygments" version = "2.16.1" @@ -1359,7 +2117,7 @@ files = [ [[package]] name = "pytest" -version = "7.4.3" +version = "7.4.4" requires_python = ">=3.7" summary = "pytest: simple powerful testing with Python" dependencies = [ @@ -1371,8 +2129,8 @@ dependencies = [ "tomli>=1.0.0; python_version < \"3.11\"", ] files = [ - {file = "pytest-7.4.3-py3-none-any.whl", hash = "sha256:0d009c083ea859a71b76adf7c1d502e4bc170b80a8ef002da5806527b9591fac"}, - {file = "pytest-7.4.3.tar.gz", hash = "sha256:d989d136982de4e3b29dabcc838ad581c64e8ed52c11fbe86ddebd9da0818cd5"}, + {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"}, + {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"}, ] [[package]] @@ -1388,6 +2146,16 @@ files = [ {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, ] +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +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 = "python-lsp-jsonrpc" version = "1.1.2" @@ -1428,6 +2196,35 @@ files = [ {file = "pytz-2023.3.post1.tar.gz", hash = "sha256:7b4fddbeb94a1eba4b557da24f19fdf9db575192544270a9101d8509f9f43d7b"}, ] +[[package]] +name = "pywin32" +version = "306" +summary = "Python for Window Extensions" +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-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.12" +requires_python = ">=3.8" +summary = "Pseudo terminal support for Windows from Python." +files = [ + {file = "pywinpty-2.0.12-cp310-none-win_amd64.whl", hash = "sha256:21319cd1d7c8844fb2c970fb3a55a3db5543f112ff9cfcd623746b9c47501575"}, + {file = "pywinpty-2.0.12-cp311-none-win_amd64.whl", hash = "sha256:853985a8f48f4731a716653170cd735da36ffbdc79dcb4c7b7140bce11d8c722"}, + {file = "pywinpty-2.0.12-cp38-none-win_amd64.whl", hash = "sha256:189380469ca143d06e19e19ff3fba0fcefe8b4a8cc942140a6b863aed7eebb2d"}, + {file = "pywinpty-2.0.12-cp39-none-win_amd64.whl", hash = "sha256:7520575b6546db23e693cbd865db2764097bd6d4ef5dc18c92555904cd62c3d4"}, + {file = "pywinpty-2.0.12.tar.gz", hash = "sha256:8197de460ae8ebb7f5d1701dfa1b5df45b157bb832e92acba316305e18ca00dd"}, +] + [[package]] name = "pyyaml" version = "6.0.1" @@ -1468,6 +2265,95 @@ files = [ {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, ] +[[package]] +name = "pyzmq" +version = "25.1.2" +requires_python = ">=3.6" +summary = "Python bindings for 0MQ" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-25.1.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:e624c789359f1a16f83f35e2c705d07663ff2b4d4479bad35621178d8f0f6ea4"}, + {file = "pyzmq-25.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:49151b0efece79f6a79d41a461d78535356136ee70084a1c22532fc6383f4ad0"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9a5f194cf730f2b24d6af1f833c14c10f41023da46a7f736f48b6d35061e76e"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:faf79a302f834d9e8304fafdc11d0d042266667ac45209afa57e5efc998e3872"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f51a7b4ead28d3fca8dda53216314a553b0f7a91ee8fc46a72b402a78c3e43d"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:0ddd6d71d4ef17ba5a87becf7ddf01b371eaba553c603477679ae817a8d84d75"}, + {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:246747b88917e4867e2367b005fc8eefbb4a54b7db363d6c92f89d69abfff4b6"}, + {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:00c48ae2fd81e2a50c3485de1b9d5c7c57cd85dc8ec55683eac16846e57ac979"}, + {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5a68d491fc20762b630e5db2191dd07ff89834086740f70e978bb2ef2668be08"}, + {file = "pyzmq-25.1.2-cp310-cp310-win32.whl", hash = "sha256:09dfe949e83087da88c4a76767df04b22304a682d6154de2c572625c62ad6886"}, + {file = "pyzmq-25.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:fa99973d2ed20417744fca0073390ad65ce225b546febb0580358e36aa90dba6"}, + {file = "pyzmq-25.1.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:82544e0e2d0c1811482d37eef297020a040c32e0687c1f6fc23a75b75db8062c"}, + {file = "pyzmq-25.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:01171fc48542348cd1a360a4b6c3e7d8f46cdcf53a8d40f84db6707a6768acc1"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc69c96735ab501419c432110016329bf0dea8898ce16fab97c6d9106dc0b348"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3e124e6b1dd3dfbeb695435dff0e383256655bb18082e094a8dd1f6293114642"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7598d2ba821caa37a0f9d54c25164a4fa351ce019d64d0b44b45540950458840"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d1299d7e964c13607efd148ca1f07dcbf27c3ab9e125d1d0ae1d580a1682399d"}, + {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4e6f689880d5ad87918430957297c975203a082d9a036cc426648fcbedae769b"}, + {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:cc69949484171cc961e6ecd4a8911b9ce7a0d1f738fcae717177c231bf77437b"}, + {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9880078f683466b7f567b8624bfc16cad65077be046b6e8abb53bed4eeb82dd3"}, + {file = "pyzmq-25.1.2-cp311-cp311-win32.whl", hash = "sha256:4e5837af3e5aaa99a091302df5ee001149baff06ad22b722d34e30df5f0d9097"}, + {file = "pyzmq-25.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:25c2dbb97d38b5ac9fd15586e048ec5eb1e38f3d47fe7d92167b0c77bb3584e9"}, + {file = "pyzmq-25.1.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:bef02cfcbded83473bdd86dd8d3729cd82b2e569b75844fb4ea08fee3c26ae41"}, + {file = "pyzmq-25.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e10a4b5a4b1192d74853cc71a5e9fd022594573926c2a3a4802020360aa719d8"}, + {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8c5f80e578427d4695adac6fdf4370c14a2feafdc8cb35549c219b90652536ae"}, + {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5dde6751e857910c1339890f3524de74007958557593b9e7e8c5f01cd919f8a7"}, + {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea1608dd169da230a0ad602d5b1ebd39807ac96cae1845c3ceed39af08a5c6df"}, + {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0f513130c4c361201da9bc69df25a086487250e16b5571ead521b31ff6b02220"}, + {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:019744b99da30330798bb37df33549d59d380c78e516e3bab9c9b84f87a9592f"}, + {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2e2713ef44be5d52dd8b8e2023d706bf66cb22072e97fc71b168e01d25192755"}, + {file = "pyzmq-25.1.2-cp38-cp38-win32.whl", hash = "sha256:07cd61a20a535524906595e09344505a9bd46f1da7a07e504b315d41cd42eb07"}, + {file = "pyzmq-25.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb7e49a17fb8c77d3119d41a4523e432eb0c6932187c37deb6fbb00cc3028088"}, + {file = "pyzmq-25.1.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:94504ff66f278ab4b7e03e4cba7e7e400cb73bfa9d3d71f58d8972a8dc67e7a6"}, + {file = "pyzmq-25.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6dd0d50bbf9dca1d0bdea219ae6b40f713a3fb477c06ca3714f208fd69e16fd8"}, + {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:004ff469d21e86f0ef0369717351073e0e577428e514c47c8480770d5e24a565"}, + {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c0b5ca88a8928147b7b1e2dfa09f3b6c256bc1135a1338536cbc9ea13d3b7add"}, + {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c9a79f1d2495b167119d02be7448bfba57fad2a4207c4f68abc0bab4b92925b"}, + {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:518efd91c3d8ac9f9b4f7dd0e2b7b8bf1a4fe82a308009016b07eaa48681af82"}, + {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:1ec23bd7b3a893ae676d0e54ad47d18064e6c5ae1fadc2f195143fb27373f7f6"}, + {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:db36c27baed588a5a8346b971477b718fdc66cf5b80cbfbd914b4d6d355e44e2"}, + {file = "pyzmq-25.1.2-cp39-cp39-win32.whl", hash = "sha256:39b1067f13aba39d794a24761e385e2eddc26295826530a8c7b6c6c341584289"}, + {file = "pyzmq-25.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:8e9f3fabc445d0ce320ea2c59a75fe3ea591fdbdeebec5db6de530dd4b09412e"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a8c1d566344aee826b74e472e16edae0a02e2a044f14f7c24e123002dcff1c05"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:759cfd391a0996345ba94b6a5110fca9c557ad4166d86a6e81ea526c376a01e8"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c61e346ac34b74028ede1c6b4bcecf649d69b707b3ff9dc0fab453821b04d1e"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4cb8fc1f8d69b411b8ec0b5f1ffbcaf14c1db95b6bccea21d83610987435f1a4"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:3c00c9b7d1ca8165c610437ca0c92e7b5607b2f9076f4eb4b095c85d6e680a1d"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:df0c7a16ebb94452d2909b9a7b3337940e9a87a824c4fc1c7c36bb4404cb0cde"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:45999e7f7ed5c390f2e87ece7f6c56bf979fb213550229e711e45ecc7d42ccb8"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ac170e9e048b40c605358667aca3d94e98f604a18c44bdb4c102e67070f3ac9b"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1b604734bec94f05f81b360a272fc824334267426ae9905ff32dc2be433ab96"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:a793ac733e3d895d96f865f1806f160696422554e46d30105807fdc9841b9f7d"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0806175f2ae5ad4b835ecd87f5f85583316b69f17e97786f7443baaf54b9bb98"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ef12e259e7bc317c7597d4f6ef59b97b913e162d83b421dd0db3d6410f17a244"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ea253b368eb41116011add00f8d5726762320b1bda892f744c91997b65754d73"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b9b1f2ad6498445a941d9a4fee096d387fee436e45cc660e72e768d3d8ee611"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:8b14c75979ce932c53b79976a395cb2a8cd3aaf14aef75e8c2cb55a330b9b49d"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:889370d5174a741a62566c003ee8ddba4b04c3f09a97b8000092b7ca83ec9c49"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9a18fff090441a40ffda8a7f4f18f03dc56ae73f148f1832e109f9bffa85df15"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99a6b36f95c98839ad98f8c553d8507644c880cf1e0a57fe5e3a3f3969040882"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4345c9a27f4310afbb9c01750e9461ff33d6fb74cd2456b107525bbeebcb5be3"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3516e0b6224cf6e43e341d56da15fd33bdc37fa0c06af4f029f7d7dfceceabbc"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:146b9b1f29ead41255387fb07be56dc29639262c0f7344f570eecdcd8d683314"}, + {file = "pyzmq-25.1.2.tar.gz", hash = "sha256:93f1aa311e8bb912e34f004cf186407a4e90eec4f0ecc0efd26056bf7eda0226"}, +] + +[[package]] +name = "referencing" +version = "0.32.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.32.1-py3-none-any.whl", hash = "sha256:7e4dc12271d8e15612bfe35792f5ea1c40970dadf8624602e33db2758f7ee554"}, + {file = "referencing-0.32.1.tar.gz", hash = "sha256:3c57da0513e9563eb7e203ebe9bb3a1b509b042016433bd1e45a2853466c3dd3"}, +] + [[package]] name = "requests" version = "2.31.0" @@ -1485,28 +2371,145 @@ files = [ ] [[package]] -name = "ruff" +name = "rfc3339-validator" version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +dependencies = [ + "six", +] +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]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +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.16.2" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +files = [ + {file = "rpds_py-0.16.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:509b617ac787cd1149600e731db9274ebbef094503ca25158e6f23edaba1ca8f"}, + {file = "rpds_py-0.16.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:413b9c17388bbd0d87a329d8e30c1a4c6e44e2bb25457f43725a8e6fe4161e9e"}, + {file = "rpds_py-0.16.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2946b120718eba9af2b4dd103affc1164a87b9e9ebff8c3e4c05d7b7a7e274e2"}, + {file = "rpds_py-0.16.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:35ae5ece284cf36464eb160880018cf6088a9ac5ddc72292a6092b6ef3f4da53"}, + {file = "rpds_py-0.16.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc6a7620ba7639a3db6213da61312cb4aa9ac0ca6e00dc1cbbdc21c2aa6eb57"}, + {file = "rpds_py-0.16.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8cb6fe8ecdfffa0e711a75c931fb39f4ba382b4b3ccedeca43f18693864fe850"}, + {file = "rpds_py-0.16.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dace7b26a13353e24613417ce2239491b40a6ad44e5776a18eaff7733488b44"}, + {file = "rpds_py-0.16.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1bdbc5fcb04a7309074de6b67fa9bc4b418ab3fc435fec1f2779a0eced688d04"}, + {file = "rpds_py-0.16.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f42e25c016927e2a6b1ce748112c3ab134261fc2ddc867e92d02006103e1b1b7"}, + {file = "rpds_py-0.16.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:eab36eae3f3e8e24b05748ec9acc66286662f5d25c52ad70cadab544e034536b"}, + {file = "rpds_py-0.16.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0474df4ade9a3b4af96c3d36eb81856cb9462e4c6657d4caecfd840d2a13f3c9"}, + {file = "rpds_py-0.16.2-cp310-none-win32.whl", hash = "sha256:84c5a4d1f9dd7e2d2c44097fb09fffe728629bad31eb56caf97719e55575aa82"}, + {file = "rpds_py-0.16.2-cp310-none-win_amd64.whl", hash = "sha256:2bd82db36cd70b3628c0c57d81d2438e8dd4b7b32a6a9f25f24ab0e657cb6c4e"}, + {file = "rpds_py-0.16.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:adc0c3d6fc6ae35fee3e4917628983f6ce630d513cbaad575b4517d47e81b4bb"}, + {file = "rpds_py-0.16.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ec23fcad480e77ede06cf4127a25fc440f7489922e17fc058f426b5256ee0edb"}, + {file = "rpds_py-0.16.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07aab64e2808c3ebac2a44f67e9dc0543812b715126dfd6fe4264df527556cb6"}, + {file = "rpds_py-0.16.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a4ebb8b20bd09c5ce7884c8f0388801100f5e75e7f733b1b6613c713371feefc"}, + {file = "rpds_py-0.16.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3d7e2ea25d3517c6d7e5a1cc3702cffa6bd18d9ef8d08d9af6717fc1c700eed"}, + {file = "rpds_py-0.16.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f28ac0e8e7242d140f99402a903a2c596ab71550272ae9247ad78f9a932b5698"}, + {file = "rpds_py-0.16.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19f00f57fdd38db4bb5ad09f9ead1b535332dbf624200e9029a45f1f35527ebb"}, + {file = "rpds_py-0.16.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3da5a4c56953bdbf6d04447c3410309616c54433146ccdb4a277b9cb499bc10e"}, + {file = "rpds_py-0.16.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec2e1cf025b2c0f48ec17ff3e642661da7ee332d326f2e6619366ce8e221f018"}, + {file = "rpds_py-0.16.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e0441fb4fdd39a230477b2ca9be90868af64425bfe7b122b57e61e45737a653b"}, + {file = "rpds_py-0.16.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9f0350ef2fba5f34eb0c9000ea328e51b9572b403d2f7f3b19f24085f6f598e8"}, + {file = "rpds_py-0.16.2-cp311-none-win32.whl", hash = "sha256:5a80e2f83391ad0808b4646732af2a7b67550b98f0cae056cb3b40622a83dbb3"}, + {file = "rpds_py-0.16.2-cp311-none-win_amd64.whl", hash = "sha256:e04e56b4ca7a770593633556e8e9e46579d66ec2ada846b401252a2bdcf70a6d"}, + {file = "rpds_py-0.16.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:071980663c273bf3d388fe5c794c547e6f35ba3335477072c713a3176bf14a60"}, + {file = "rpds_py-0.16.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:726ac36e8a3bb8daef2fd482534cabc5e17334052447008405daca7ca04a3108"}, + {file = "rpds_py-0.16.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9e557db6a177470316c82f023e5d571811c9a4422b5ea084c85da9aa3c035fc"}, + {file = "rpds_py-0.16.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:90123853fc8b1747f80b0d354be3d122b4365a93e50fc3aacc9fb4c2488845d6"}, + {file = "rpds_py-0.16.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a61f659665a39a4d17d699ab3593d7116d66e1e2e3f03ef3fb8f484e91908808"}, + {file = "rpds_py-0.16.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc97f0640e91d7776530f06e6836c546c1c752a52de158720c4224c9e8053cad"}, + {file = "rpds_py-0.16.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44a54e99a2b9693a37ebf245937fd6e9228b4cbd64b9cc961e1f3391ec6c7391"}, + {file = "rpds_py-0.16.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bd4b677d929cf1f6bac07ad76e0f2d5de367e6373351c01a9c0a39f6b21b4a8b"}, + {file = "rpds_py-0.16.2-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:5ef00873303d678aaf8b0627e111fd434925ca01c657dbb2641410f1cdaef261"}, + {file = "rpds_py-0.16.2-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:349cb40897fd529ca15317c22c0eab67f5ac5178b5bd2c6adc86172045210acc"}, + {file = "rpds_py-0.16.2-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:2ddef620e70eaffebed5932ce754d539c0930f676aae6212f8e16cd9743dd365"}, + {file = "rpds_py-0.16.2-cp38-none-win32.whl", hash = "sha256:882ce6e25e585949c3d9f9abd29202367175e0aab3aba0c58c9abbb37d4982ff"}, + {file = "rpds_py-0.16.2-cp38-none-win_amd64.whl", hash = "sha256:f4bd4578e44f26997e9e56c96dedc5f1af43cc9d16c4daa29c771a00b2a26851"}, + {file = "rpds_py-0.16.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:69ac7ea9897ec201ce68b48582f3eb34a3f9924488a5432a93f177bf76a82a7e"}, + {file = "rpds_py-0.16.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a9880b4656efe36ccad41edc66789e191e5ee19a1ea8811e0aed6f69851a82f4"}, + {file = "rpds_py-0.16.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee94cb58c0ba2c62ee108c2b7c9131b2c66a29e82746e8fa3aa1a1effbd3dcf1"}, + {file = "rpds_py-0.16.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:24f7a2eb3866a9e91f4599851e0c8d39878a470044875c49bd528d2b9b88361c"}, + {file = "rpds_py-0.16.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ca57468da2d9a660bcf8961637c85f2fbb2aa64d9bc3f9484e30c3f9f67b1dd7"}, + {file = "rpds_py-0.16.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ccd4e400309e1f34a5095bf9249d371f0fd60f8a3a5c4a791cad7b99ce1fd38d"}, + {file = "rpds_py-0.16.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80443fe2f7b3ea3934c5d75fb0e04a5dbb4a8e943e5ff2de0dec059202b70a8b"}, + {file = "rpds_py-0.16.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4d6a9f052e72d493efd92a77f861e45bab2f6be63e37fa8ecf0c6fd1a58fedb0"}, + {file = "rpds_py-0.16.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:35953f4f2b3216421af86fd236b7c0c65935936a94ea83ddbd4904ba60757773"}, + {file = "rpds_py-0.16.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:981d135c7cdaf6cd8eadae1c950de43b976de8f09d8e800feed307140d3d6d00"}, + {file = "rpds_py-0.16.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d0dd7ed2f16df2e129496e7fbe59a34bc2d7fc8db443a606644d069eb69cbd45"}, + {file = "rpds_py-0.16.2-cp39-none-win32.whl", hash = "sha256:703d95c75a72e902544fda08e965885525e297578317989fd15a6ce58414b41d"}, + {file = "rpds_py-0.16.2-cp39-none-win_amd64.whl", hash = "sha256:e93ec1b300acf89730cf27975ef574396bc04edecc358e9bd116fb387a123239"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:44627b6ca7308680a70766454db5249105fa6344853af6762eaad4158a2feebe"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:3f91df8e6dbb7360e176d1affd5fb0246d2b88d16aa5ebc7db94fd66b68b61da"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d904c5693e08bad240f16d79305edba78276be87061c872a4a15e2c301fa2c0"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:290a81cfbe4673285cdf140ec5cd1658ffbf63ab359f2b352ebe172e7cfa5bf0"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b634c5ec0103c5cbebc24ebac4872b045cccb9456fc59efdcf6fe39775365bd2"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a297a4d08cc67c7466c873c78039d87840fb50d05473db0ec1b7b03d179bf322"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2e75e17bd0bb66ee34a707da677e47c14ee51ccef78ed6a263a4cc965a072a1"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f1b9d9260e06ea017feb7172976ab261e011c1dc2f8883c7c274f6b2aabfe01a"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:162d7cd9cd311c1b0ff1c55a024b8f38bd8aad1876b648821da08adc40e95734"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:9b32f742ce5b57201305f19c2ef7a184b52f6f9ba6871cc042c2a61f0d6b49b8"}, + {file = "rpds_py-0.16.2-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac08472f41ea77cd6a5dae36ae7d4ed3951d6602833af87532b556c1b4601d63"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:495a14b72bbe217f2695dcd9b5ab14d4f8066a00f5d209ed94f0aca307f85f6e"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:8d6b6937ae9eac6d6c0ca3c42774d89fa311f55adff3970fb364b34abde6ed3d"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a61226465bda9283686db8f17d02569a98e4b13c637be5a26d44aa1f1e361c2"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5cf6af100ffb5c195beec11ffaa8cf8523057f123afa2944e6571d54da84cdc9"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6df15846ee3fb2e6397fe25d7ca6624af9f89587f3f259d177b556fed6bebe2c"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1be2f033df1b8be8c3167ba3c29d5dca425592ee31e35eac52050623afba5772"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96f957d6ab25a78b9e7fc9749d754b98eac825a112b4e666525ce89afcbd9ed5"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:088396c7c70e59872f67462fcac3ecbded5233385797021976a09ebd55961dfe"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:4c46ad6356e1561f2a54f08367d1d2e70a0a1bb2db2282d2c1972c1d38eafc3b"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:47713dc4fce213f5c74ca8a1f6a59b622fc1b90868deb8e8e4d993e421b4b39d"}, + {file = "rpds_py-0.16.2-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:f811771019f063bbd0aa7bb72c8a934bc13ebacb4672d712fc1639cfd314cccc"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f19afcfc0dd0dca35694df441e9b0f95bc231b512f51bded3c3d8ca32153ec19"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a4b682c5775d6a3d21e314c10124599976809455ee67020e8e72df1769b87bc3"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c647ca87fc0ebe808a41de912e9a1bfef9acb85257e5d63691364ac16b81c1f0"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:302bd4983bbd47063e452c38be66153760112f6d3635c7eeefc094299fa400a9"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bf721ede3eb7b829e4a9b8142bd55db0bdc82902720548a703f7e601ee13bdc3"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:358dafc89ce3894c7f486c615ba914609f38277ef67f566abc4c854d23b997fa"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cad0f59ee3dc35526039f4bc23642d52d5f6616b5f687d846bfc6d0d6d486db0"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cffa76b385dfe1e38527662a302b19ffb0e7f5cf7dd5e89186d2c94a22dd9d0c"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:83640a5d7cd3bff694747d50436b8b541b5b9b9782b0c8c1688931d6ee1a1f2d"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:ed99b4f7179d2111702020fd7d156e88acd533f5a7d3971353e568b6051d5c97"}, + {file = "rpds_py-0.16.2-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4022b9dc620e14f30201a8a73898a873c8e910cb642bcd2f3411123bc527f6ac"}, + {file = "rpds_py-0.16.2.tar.gz", hash = "sha256:781ef8bfc091b19960fc0142a23aedadafa826bc32b433fdfe6fd7f964d7ef44"}, +] + +[[package]] +name = "ruff" +version = "0.1.11" requires_python = ">=3.7" summary = "An extremely fast Python linter and code formatter, written in Rust." files = [ - {file = "ruff-0.1.4-py3-none-macosx_10_7_x86_64.whl", hash = "sha256:864958706b669cce31d629902175138ad8a069d99ca53514611521f532d91495"}, - {file = "ruff-0.1.4-py3-none-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:9fdd61883bb34317c788af87f4cd75dfee3a73f5ded714b77ba928e418d6e39e"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4eaca8c9cc39aa7f0f0d7b8fe24ecb51232d1bb620fc4441a61161be4a17539"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a9a1301dc43cbf633fb603242bccd0aaa34834750a14a4c1817e2e5c8d60de17"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78e8db8ab6f100f02e28b3d713270c857d370b8d61871d5c7d1702ae411df683"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:80fea754eaae06335784b8ea053d6eb8e9aac75359ebddd6fee0858e87c8d510"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6bc02a480d4bfffd163a723698da15d1a9aec2fced4c06f2a753f87f4ce6969c"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9862811b403063765b03e716dac0fda8fdbe78b675cd947ed5873506448acea4"}, - {file = "ruff-0.1.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58826efb8b3efbb59bb306f4b19640b7e366967a31c049d49311d9eb3a4c60cb"}, - {file = "ruff-0.1.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:fdfd453fc91d9d86d6aaa33b1bafa69d114cf7421057868f0b79104079d3e66e"}, - {file = "ruff-0.1.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e8791482d508bd0b36c76481ad3117987301b86072158bdb69d796503e1c84a8"}, - {file = "ruff-0.1.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:01206e361021426e3c1b7fba06ddcb20dbc5037d64f6841e5f2b21084dc51800"}, - {file = "ruff-0.1.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:645591a613a42cb7e5c2b667cbefd3877b21e0252b59272ba7212c3d35a5819f"}, - {file = "ruff-0.1.4-py3-none-win32.whl", hash = "sha256:99908ca2b3b85bffe7e1414275d004917d1e0dfc99d497ccd2ecd19ad115fd0d"}, - {file = "ruff-0.1.4-py3-none-win_amd64.whl", hash = "sha256:1dfd6bf8f6ad0a4ac99333f437e0ec168989adc5d837ecd38ddb2cc4a2e3db8a"}, - {file = "ruff-0.1.4-py3-none-win_arm64.whl", hash = "sha256:d98ae9ebf56444e18a3e3652b3383204748f73e247dea6caaf8b52d37e6b32da"}, - {file = "ruff-0.1.4.tar.gz", hash = "sha256:21520ecca4cc555162068d87c747b8f95e1e95f8ecfcbbe59e8dd00710586315"}, + {file = "ruff-0.1.11-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:a7f772696b4cdc0a3b2e527fc3c7ccc41cdcb98f5c80fdd4f2b8c50eb1458196"}, + {file = "ruff-0.1.11-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:934832f6ed9b34a7d5feea58972635c2039c7a3b434fe5ba2ce015064cb6e955"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea0d3e950e394c4b332bcdd112aa566010a9f9c95814844a7468325290aabfd9"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9bd4025b9c5b429a48280785a2b71d479798a69f5c2919e7d274c5f4b32c3607"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1ad00662305dcb1e987f5ec214d31f7d6a062cae3e74c1cbccef15afd96611d"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:4b077ce83f47dd6bea1991af08b140e8b8339f0ba8cb9b7a484c30ebab18a23f"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4a88efecec23c37b11076fe676e15c6cdb1271a38f2b415e381e87fe4517f18"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5b25093dad3b055667730a9b491129c42d45e11cdb7043b702e97125bcec48a1"}, + {file = "ruff-0.1.11-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:231d8fb11b2cc7c0366a326a66dafc6ad449d7fcdbc268497ee47e1334f66f77"}, + {file = "ruff-0.1.11-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:09c415716884950080921dd6237767e52e227e397e2008e2bed410117679975b"}, + {file = "ruff-0.1.11-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:0f58948c6d212a6b8d41cd59e349751018797ce1727f961c2fa755ad6208ba45"}, + {file = "ruff-0.1.11-py3-none-musllinux_1_2_i686.whl", hash = "sha256:190a566c8f766c37074d99640cd9ca3da11d8deae2deae7c9505e68a4a30f740"}, + {file = "ruff-0.1.11-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6464289bd67b2344d2a5d9158d5eb81025258f169e69a46b741b396ffb0cda95"}, + {file = "ruff-0.1.11-py3-none-win32.whl", hash = "sha256:9b8f397902f92bc2e70fb6bebfa2139008dc72ae5177e66c383fa5426cb0bf2c"}, + {file = "ruff-0.1.11-py3-none-win_amd64.whl", hash = "sha256:eb85ee287b11f901037a6683b2374bb0ec82928c5cbc984f575d0437979c521a"}, + {file = "ruff-0.1.11-py3-none-win_arm64.whl", hash = "sha256:97ce4d752f964ba559c7023a86e5f8e97f026d511e48013987623915431c7ea9"}, + {file = "ruff-0.1.11.tar.gz", hash = "sha256:f9d4d88cb6eeb4dfe20f9f0519bd2eaba8119bde87c3d5065c541dbae2b5a2cb"}, ] [[package]] @@ -1541,6 +2544,16 @@ files = [ {file = "scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5"}, ] +[[package]] +name = "send2trash" +version = "1.8.2" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +files = [ + {file = "Send2Trash-1.8.2-py3-none-any.whl", hash = "sha256:a384719d99c07ce1eefd6905d2decb6f8b7ed054025bb0e618919f945de4f679"}, + {file = "Send2Trash-1.8.2.tar.gz", hash = "sha256:c132d59fa44b9ca2b1699af5c86f57ce9f4c5eb56629d5d55fbb7a35f84e2312"}, +] + [[package]] name = "setuptools" version = "68.2.2" @@ -1561,6 +2574,16 @@ files = [ {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, ] +[[package]] +name = "sniffio" +version = "1.3.0" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +files = [ + {file = "sniffio-1.3.0-py3-none-any.whl", hash = "sha256:eecefdce1e5bbfb7ad2eeaabf7c1eeb404d7757c379bd1f7e5cce9d8bf425384"}, + {file = "sniffio-1.3.0.tar.gz", hash = "sha256:e60305c5e5d314f5389259b7f22aaa33d8f7dee49763119234af3755c55b9101"}, +] + [[package]] name = "snowballstemmer" version = "2.2.0" @@ -1570,6 +2593,16 @@ files = [ {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, ] +[[package]] +name = "soupsieve" +version = "2.5" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +files = [ + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, +] + [[package]] name = "sphinx" version = "6.2.1" @@ -1614,21 +2647,6 @@ files = [ {file = "sphinx_click-4.4.0-py3-none-any.whl", hash = "sha256:2821c10a68fc9ee6ce7c92fad26540d8d8c8f45e6d7258f0e4fb7529ae8fab49"}, ] -[[package]] -name = "sphinx-rtd-theme" -version = "1.3.0" -requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" -summary = "Read the Docs theme for Sphinx" -dependencies = [ - "docutils<0.19", - "sphinx<8,>=1.6", - "sphinxcontrib-jquery<5,>=4", -] -files = [ - {file = "sphinx_rtd_theme-1.3.0-py2.py3-none-any.whl", hash = "sha256:46ddef89cc2416a81ecfbeaceab1881948c014b1b6e4450b815311a89fb977b0"}, - {file = "sphinx_rtd_theme-1.3.0.tar.gz", hash = "sha256:590b030c7abb9cf038ec053b95e5380b5c70d61591eb0b552063fbe7c41f0931"}, -] - [[package]] name = "sphinxcontrib-applehelp" version = "1.0.4" @@ -1659,19 +2677,6 @@ files = [ {file = "sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903"}, ] -[[package]] -name = "sphinxcontrib-jquery" -version = "4.1" -requires_python = ">=2.7" -summary = "Extension to include jQuery on newer Sphinx releases" -dependencies = [ - "Sphinx>=1.8", -] -files = [ - {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, - {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, -] - [[package]] name = "sphinxcontrib-jsmath" version = "1.0.1" @@ -1749,6 +2754,34 @@ files = [ {file = "tables-3.8.0.tar.gz", hash = "sha256:34f3fa2366ce20b18f1df573a77c1d27306ce1f2a41d9f9eff621b5192ea8788"}, ] +[[package]] +name = "terminado" +version = "0.18.0" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.0-py3-none-any.whl", hash = "sha256:87b0d96642d0fe5f5abd7783857b9cab167f221a39ff98e3b9619a788a3c0f2e"}, + {file = "terminado-0.18.0.tar.gz", hash = "sha256:1ea08a89b835dd1b8c0c900d92848147cef2537243361b2e3f4dc15df9b6fded"}, +] + +[[package]] +name = "tinycss2" +version = "1.2.1" +requires_python = ">=3.7" +summary = "A tiny CSS parser" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + [[package]] name = "toml" version = "0.10.2" @@ -1769,6 +2802,25 @@ files = [ {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] +[[package]] +name = "tornado" +version = "6.4" +requires_python = ">= 3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +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 = "tqdm" version = "4.66.1" @@ -1792,6 +2844,16 @@ files = [ {file = "traitlets-5.13.0.tar.gz", hash = "sha256:9b232b9430c8f57288c1024b34a8f0251ddcc47268927367a0dd3eeaca40deb5"}, ] +[[package]] +name = "types-python-dateutil" +version = "2.8.19.20240106" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +files = [ + {file = "types-python-dateutil-2.8.19.20240106.tar.gz", hash = "sha256:1f8db221c3b98e6ca02ea83a58371b22c374f42ae5bbdf186db9c9a76581459f"}, + {file = "types_python_dateutil-2.8.19.20240106-py3-none-any.whl", hash = "sha256:efbbdc54590d0f16152fa103c9879c7d4a00e82078f6e2cf01769042165acaa2"}, +] + [[package]] name = "types-toml" version = "0.10.8.7" @@ -1803,12 +2865,12 @@ files = [ [[package]] name = "types-tqdm" -version = "4.66.0.4" -requires_python = ">=3.7" +version = "4.66.0.20240106" +requires_python = ">=3.8" summary = "Typing stubs for tqdm" files = [ - {file = "types-tqdm-4.66.0.4.tar.gz", hash = "sha256:a2f0ebd4cfd48f4914395819a176d7947387e1b98f9228fca38f8cac1b59891c"}, - {file = "types_tqdm-4.66.0.4-py3-none-any.whl", hash = "sha256:8eda4c5123dd66985a4cb44268705cfa18beb32d66772271ae185e92b8b10c40"}, + {file = "types-tqdm-4.66.0.20240106.tar.gz", hash = "sha256:7acf4aade5bad3ded76eb829783f9961b1c2187948eaa6dd1ae8644dff95a938"}, + {file = "types_tqdm-4.66.0.20240106-py3-none-any.whl", hash = "sha256:7459b0f441b969735685645a5d8480f7912b10d05ab45f99a2db8a8e45cb550b"}, ] [[package]] @@ -1890,6 +2952,16 @@ files = [ {file = "ujson-5.8.0.tar.gz", hash = "sha256:78e318def4ade898a461b3d92a79f9441e7e0e4d2ad5419abed4336d702c7425"}, ] +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +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]] name = "urllib3" version = "2.0.7" @@ -1925,53 +2997,32 @@ files = [ ] [[package]] -name = "wrapt" -version = "1.15.0" -requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" -summary = "Module for decorators, wrappers and monkey patching." -files = [ - {file = "wrapt-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:21f6d9a0d5b3a207cdf7acf8e58d7d13d463e639f0c7e01d82cdb671e6cb7923"}, - {file = "wrapt-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce42618f67741d4697684e501ef02f29e758a123aa2d669e2d964ff734ee00ee"}, - {file = "wrapt-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41d07d029dd4157ae27beab04d22b8e261eddfc6ecd64ff7000b10dc8b3a5727"}, - {file = "wrapt-1.15.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54accd4b8bc202966bafafd16e69da9d5640ff92389d33d28555c5fd4f25ccb7"}, - {file = "wrapt-1.15.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fbfbca668dd15b744418265a9607baa970c347eefd0db6a518aaf0cfbd153c0"}, - {file = "wrapt-1.15.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:76e9c727a874b4856d11a32fb0b389afc61ce8aaf281ada613713ddeadd1cfec"}, - {file = "wrapt-1.15.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e20076a211cd6f9b44a6be58f7eeafa7ab5720eb796975d0c03f05b47d89eb90"}, - {file = "wrapt-1.15.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a74d56552ddbde46c246b5b89199cb3fd182f9c346c784e1a93e4dc3f5ec9975"}, - {file = "wrapt-1.15.0-cp310-cp310-win32.whl", hash = "sha256:26458da5653aa5b3d8dc8b24192f574a58984c749401f98fff994d41d3f08da1"}, - {file = "wrapt-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:75760a47c06b5974aa5e01949bf7e66d2af4d08cb8c1d6516af5e39595397f5e"}, - {file = "wrapt-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ba1711cda2d30634a7e452fc79eabcadaffedf241ff206db2ee93dd2c89a60e7"}, - {file = "wrapt-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:56374914b132c702aa9aa9959c550004b8847148f95e1b824772d453ac204a72"}, - {file = "wrapt-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a89ce3fd220ff144bd9d54da333ec0de0399b52c9ac3d2ce34b569cf1a5748fb"}, - {file = "wrapt-1.15.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3bbe623731d03b186b3d6b0d6f51865bf598587c38d6f7b0be2e27414f7f214e"}, - {file = "wrapt-1.15.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3abbe948c3cbde2689370a262a8d04e32ec2dd4f27103669a45c6929bcdbfe7c"}, - {file = "wrapt-1.15.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b67b819628e3b748fd3c2192c15fb951f549d0f47c0449af0764d7647302fda3"}, - {file = "wrapt-1.15.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7eebcdbe3677e58dd4c0e03b4f2cfa346ed4049687d839adad68cc38bb559c92"}, - {file = "wrapt-1.15.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:74934ebd71950e3db69960a7da29204f89624dde411afbfb3b4858c1409b1e98"}, - {file = "wrapt-1.15.0-cp311-cp311-win32.whl", hash = "sha256:bd84395aab8e4d36263cd1b9308cd504f6cf713b7d6d3ce25ea55670baec5416"}, - {file = "wrapt-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:a487f72a25904e2b4bbc0817ce7a8de94363bd7e79890510174da9d901c38705"}, - {file = "wrapt-1.15.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cdb4f085756c96a3af04e6eca7f08b1345e94b53af8921b25c72f096e704e145"}, - {file = "wrapt-1.15.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:230ae493696a371f1dbffaad3dafbb742a4d27a0afd2b1aecebe52b740167e7f"}, - {file = "wrapt-1.15.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63424c681923b9f3bfbc5e3205aafe790904053d42ddcc08542181a30a7a51bd"}, - {file = "wrapt-1.15.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d6bcbfc99f55655c3d93feb7ef3800bd5bbe963a755687cbf1f490a71fb7794b"}, - {file = "wrapt-1.15.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c99f4309f5145b93eca6e35ac1a988f0dc0a7ccf9ccdcd78d3c0adf57224e62f"}, - {file = "wrapt-1.15.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b130fe77361d6771ecf5a219d8e0817d61b236b7d8b37cc045172e574ed219e6"}, - {file = "wrapt-1.15.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:96177eb5645b1c6985f5c11d03fc2dbda9ad24ec0f3a46dcce91445747e15094"}, - {file = "wrapt-1.15.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5fe3e099cf07d0fb5a1e23d399e5d4d1ca3e6dfcbe5c8570ccff3e9208274f7"}, - {file = "wrapt-1.15.0-cp38-cp38-win32.whl", hash = "sha256:abd8f36c99512755b8456047b7be10372fca271bf1467a1caa88db991e7c421b"}, - {file = "wrapt-1.15.0-cp38-cp38-win_amd64.whl", hash = "sha256:b06fa97478a5f478fb05e1980980a7cdf2712015493b44d0c87606c1513ed5b1"}, - {file = "wrapt-1.15.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2e51de54d4fb8fb50d6ee8327f9828306a959ae394d3e01a1ba8b2f937747d86"}, - {file = "wrapt-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0970ddb69bba00670e58955f8019bec4a42d1785db3faa043c33d81de2bf843c"}, - {file = "wrapt-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76407ab327158c510f44ded207e2f76b657303e17cb7a572ffe2f5a8a48aa04d"}, - {file = "wrapt-1.15.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cd525e0e52a5ff16653a3fc9e3dd827981917d34996600bbc34c05d048ca35cc"}, - {file = "wrapt-1.15.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d37ac69edc5614b90516807de32d08cb8e7b12260a285ee330955604ed9dd29"}, - {file = "wrapt-1.15.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:078e2a1a86544e644a68422f881c48b84fef6d18f8c7a957ffd3f2e0a74a0d4a"}, - {file = "wrapt-1.15.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:2cf56d0e237280baed46f0b5316661da892565ff58309d4d2ed7dba763d984b8"}, - {file = "wrapt-1.15.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:7dc0713bf81287a00516ef43137273b23ee414fe41a3c14be10dd95ed98a2df9"}, - {file = "wrapt-1.15.0-cp39-cp39-win32.whl", hash = "sha256:46ed616d5fb42f98630ed70c3529541408166c22cdfd4540b88d5f21006b0eff"}, - {file = "wrapt-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:eef4d64c650f33347c1f9266fa5ae001440b232ad9b98f1f43dfe7a79435c0a6"}, - {file = "wrapt-1.15.0-py3-none-any.whl", hash = "sha256:64b1df0f83706b4ef4cfb4fb0e4c2669100fd7ecacfb59e091fad300d4e04640"}, - {file = "wrapt-1.15.0.tar.gz", hash = "sha256:d06730c6aed78cee4126234cf2d071e01b44b915e725a6cb439a879ec9754a3a"}, +name = "webcolors" +version = "1.13" +requires_python = ">=3.7" +summary = "A library for working with the color formats defined by HTML and CSS." +files = [ + {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"}, + {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +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" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +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]] diff --git a/pyproject.toml b/pyproject.toml index 37bcbb4..6753385 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,9 +14,11 @@ dependencies = [ "scipy<2.0.0,>=1.10.1", "ipython>=8.12.3", "fluxcomp>=0.1.2", + "myst-parser>=2.0.0", + "nbsphinx>=0.9.3", ] name = "corsika-panama" -description = "\"PANdas And Multicore utils for corsikA7\"" +description = "\"PANdas And Multicore utils for corsikA7\" -- A python toolkit for CORSIKA7" readme = "README.md" dynamic = ["version"] @@ -118,8 +120,6 @@ dev = [ "coverage<8.0.0,>=7.1.0", "pre-commit<4.0.0,>=3.0.4", "sphinx<7.0.0,>=6.1.3", - "m2r2<0.3.3", - "sphinx-rtd-theme<2.0.0,>=1.2.0", "sphinx-click<5.0.0,>=4.4.0", "ruff<1.0.0,>=0.0.252", "mypy<2.0.0,>=1.0.1", @@ -129,6 +129,8 @@ dev = [ "toml<1.0.0,>=0.10.2", "types-toml<1.0.0.0,>=0.10.8.7", "python-lsp-server>=1.8.2", + "pydata-sphinx-theme>=0.14.4", + "notebook>=7.0.6", ] [tool.pdm.build] diff --git a/tests/test_meta.py b/tests/test_meta.py index addfb97..5f24bf5 100644 --- a/tests/test_meta.py +++ b/tests/test_meta.py @@ -34,6 +34,7 @@ def test_cli_no_tables(pytestconfig, tmp_path, caplog, monkeypatch, test_file_pa catch_exceptions=True ) + print(result.exception) assert type(result.exception) == ImportError assert "corsika-panama[hdf]" in result.exception.msg assert "corsika-panama[hdf]" in caplog.text diff --git a/tests/test_run.py b/tests/test_run.py index 9c4c342..2ac234d 100644 --- a/tests/test_run.py +++ b/tests/test_run.py @@ -13,6 +13,42 @@ CORSIKA_EXECUTABLE = "corsika77500Linux_SIBYLL_urqmd" +def test_corsika_runner_cleanup( + test_file_path=Path(__file__).parent / "files" / "example_corsika.template", +): + """ + Tests if cleanup of the runner works and a new CorsikaRunner objct + with the same tmp path can be constructed. + """ + with CorsikaRunner( + {2212: 100_000, 1000260560: 1000}, + 4, + test_file_path, + Path("/tmp/corsika_test_output"), + test_file_path.parent.parent.parent / "panama" / "cli" / "cli.py", + Path("/tmp/corsika_tmp_dir"), + ) as runner: + pass + + runner = CorsikaRunner( + {2212: 100_000, 1000260560: 1000}, + 4, + test_file_path, + Path("/tmp/corsika_test_output"), + test_file_path.parent.parent.parent / "panama" / "cli" / "cli.py", + Path("/tmp/corsika_tmp_dir"), + ) + runner.clean() + + runner = CorsikaRunner( + {2212: 100_000, 1000260560: 1000}, + 4, + test_file_path, + Path("/tmp/corsika_test_output"), + test_file_path.parent.parent.parent / "panama" / "cli" / "cli.py", + Path("/tmp/corsika_tmp_dir"), + ) + def test_run_fail( test_file_path=Path(__file__).parent / "files" / "example_corsika.template",