diff --git a/.github/dependabot.yml b/.github/dependabot.yml index c1eac3c4..2700384d 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -6,6 +6,6 @@ updates: schedule: interval: "daily" ignore: - # Offical actions have moving tags like v1 + # Official actions have moving tags like v1 # that are used, so they don't need updates here - dependency-name: "actions/*" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 89eaf7a8..84af6f12 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,26 +6,26 @@ on: merge_group: push: branches: - - master - - main - - develop + - master + - main + - develop jobs: pre-commit: name: Format runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - with: - submodules: recursive - fetch-depth: 0 - fetch-tags: true - - uses: actions/setup-python@v3 - with: - python-version: 3.12 - - uses: pre-commit/action@v3.0.0 - with: - extra_args: --hook-stage manual --all-files + - uses: actions/checkout@v4 + with: + submodules: recursive + fetch-depth: 0 + fetch-tags: true + - uses: actions/setup-python@v3 + with: + python-version: 3.12 + - uses: pre-commit/action@v3.0.0 + with: + extra_args: --hook-stage manual --all-files checks: name: Check Python ${{ matrix.python-version }} on ${{ matrix.runs-on }} @@ -37,21 +37,21 @@ jobs: runs-on: [ubuntu-latest, macos-latest, windows-latest] steps: - - uses: actions/checkout@v4 - with: - submodules: recursive - fetch-depth: 0 - fetch-tags: true + - uses: actions/checkout@v4 + with: + submodules: recursive + fetch-depth: 0 + fetch-tags: true - - uses: actions/setup-python@v6 - with: - python-version: ${{ matrix.python-version }} + - uses: actions/setup-python@v6 + with: + python-version: ${{ matrix.python-version }} - - name: Install package - run: python -m pip install . --group test + - name: Install package + run: python -m pip install . --group test - - name: Test package - run: python -m pytest -ra + - name: Test package + run: pytest checkroot: name: Check ROOT bindings @@ -81,7 +81,7 @@ jobs: - name: Test package shell: bash -l {0} - run: python -m pytest -ra + run: pytest pass: name: All tests passed diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index dc8b464a..29fff6f7 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -4,8 +4,8 @@ on: workflow_dispatch: push: branches: - - master - - main + - master + - main jobs: docs: @@ -13,28 +13,28 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - uses: actions/setup-python@v2 - with: - python-version: 3.12 - - - name: Install pandoc - uses: r-lib/actions/setup-pandoc@v2 - - - name: Install package - run: python -m pip install . --group docs - - - name: Build documentation - run: | - cd docs - make - touch build/html/.nojekyll - - - name: Deploy documentation - uses: peaceiris/actions-gh-pages@v4.0.0 - with: - github_token: ${{ secrets.GITHUB_TOKEN }} - publish_dir: ./docs/build/html + - uses: actions/checkout@v2 + with: + submodules: recursive + + - uses: actions/setup-python@v2 + with: + python-version: 3.12 + + - name: Install pandoc + uses: r-lib/actions/setup-pandoc@v2 + + - name: Install package + run: python -m pip install . --group docs + + - name: Build documentation + run: | + cd docs + make + touch build/html/.nojekyll + + - name: Deploy documentation + uses: peaceiris/actions-gh-pages@v4.0.0 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs/build/html diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 105f59cf..25728fb6 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -15,19 +15,19 @@ jobs: name: Make SDist runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - with: - submodules: recursive - fetch-tags: true - fetch-depth: 0 + - uses: actions/checkout@v4 + with: + submodules: recursive + fetch-tags: true + fetch-depth: 0 - - name: Build SDist - run: pipx run build --sdist + - name: Build SDist + run: pipx run build --sdist - - uses: actions/upload-artifact@v4 - with: - name: artifact-sdist - path: dist/*.tar.gz + - uses: actions/upload-artifact@v4 + with: + name: artifact-sdist + path: dist/*.tar.gz build_wheels: name: Wheel on ${{ matrix.os }} (${{ matrix.arch }}) @@ -42,22 +42,22 @@ jobs: arch: universal2 steps: - - uses: actions/checkout@v4 - with: - submodules: recursive - fetch-tags: true - fetch-depth: 0 + - uses: actions/checkout@v4 + with: + submodules: recursive + fetch-tags: true + fetch-depth: 0 - - uses: pypa/cibuildwheel@v3.3 - env: - CIBW_ARCHS: ${{ matrix.arch }} - MACOSX_DEPLOYMENT_TARGET: 11.0 + - uses: pypa/cibuildwheel@v3.3 + env: + CIBW_ARCHS: ${{ matrix.arch }} + MACOSX_DEPLOYMENT_TARGET: 11.0 - - name: Upload wheels - uses: actions/upload-artifact@v4 - with: - name: artifact-wheel-${{ matrix.os }}-${{ matrix.arch }} - path: wheelhouse/*.whl + - name: Upload wheels + uses: actions/upload-artifact@v4 + with: + name: artifact-wheel-${{ matrix.os }}-${{ matrix.arch }} + path: wheelhouse/*.whl pypi-publish: needs: [build_wheels, make_sdist] @@ -67,11 +67,11 @@ jobs: permissions: id-token: write steps: - - uses: actions/download-artifact@v4 - with: - path: dist - pattern: artifact-* - merge-multiple: true + - uses: actions/download-artifact@v4 + with: + path: dist + pattern: artifact-* + merge-multiple: true - - name: Publish package distributions to PyPI - uses: pypa/gh-action-pypi-publish@release/v1 + - name: Publish package distributions to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 134642aa..fb995166 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,44 +1,67 @@ repos: -- repo: https://github.com/psf/black - rev: 25.9.0 - hooks: - - id: black - -- repo: https://github.com/pre-commit/pre-commit-hooks - rev: v4.1.0 - hooks: - - id: check-added-large-files - - id: check-case-conflict - - id: check-merge-conflict - - id: check-symlinks - - id: check-yaml - - id: debug-statements - - id: end-of-file-fixer - - id: mixed-line-ending - - id: requirements-txt-fixer - - id: trailing-whitespace - -- repo: https://github.com/PyCQA/isort - rev: 5.12.0 - hooks: - - id: isort - -- repo: https://github.com/asottile/pyupgrade - rev: v3.21.0 - hooks: - - id: pyupgrade - args: ["--py39-plus"] - -- repo: https://github.com/pycqa/flake8 - rev: 7.0.0 - hooks: - - id: flake8 - exclude: docs/conf.py - additional_dependencies: [flake8-bugbear, flake8-print] - -- repo: https://github.com/pre-commit/mirrors-mypy - rev: v1.17.1 - hooks: - - id: mypy - pass_filenames: false # to allow mypy to respect pyproject.toml config - additional_dependencies: [uhi, pydantic, numpy] + - repo: https://github.com/adamchainz/blacken-docs + rev: "1.19.1" + hooks: + - id: blacken-docs + additional_dependencies: [black==24.*] + + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: "v5.0.0" + hooks: + - id: check-added-large-files + - id: check-case-conflict + - id: check-merge-conflict + - id: check-symlinks + - id: check-yaml + - id: debug-statements + - id: end-of-file-fixer + - id: mixed-line-ending + - id: name-tests-test + args: ["--pytest-test-first"] + - id: trailing-whitespace + + - repo: https://github.com/rbubley/mirrors-prettier + rev: "v3.4.2" + hooks: + - id: prettier + types_or: [yaml, markdown, html, css, scss, javascript, json] + args: [--prose-wrap=always] + exclude: binder/mycorrections.json + + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: "v0.9.2" + hooks: + - id: ruff + args: ["--fix", "--show-fixes"] + - id: ruff-format + + - repo: https://github.com/codespell-project/codespell + rev: "v2.3.0" + hooks: + - id: codespell + + - repo: https://github.com/abravalheri/validate-pyproject + rev: "v0.23" + hooks: + - id: validate-pyproject + additional_dependencies: ["validate-pyproject-schema-store[all]"] + + - repo: https://github.com/python-jsonschema/check-jsonschema + rev: "0.31.0" + hooks: + - id: check-dependabot + - id: check-github-workflows + - id: check-readthedocs + + - repo: https://github.com/asottile/pyupgrade + rev: v3.21.0 + hooks: + - id: pyupgrade + args: ["--py39-plus"] + + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.17.1 + hooks: + - id: mypy + pass_filenames: false # to allow mypy to respect pyproject.toml config + additional_dependencies: [uhi, pydantic, numpy] diff --git a/.readthedocs.yml b/.readthedocs.yml deleted file mode 100644 index e6fb9e94..00000000 --- a/.readthedocs.yml +++ /dev/null @@ -1,21 +0,0 @@ -# .readthedocs.yml -# Read the Docs configuration file -# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details - -# Required -version: 2 - -# Build documentation in the docs/ directory with Sphinx -sphinx: - configuration: docs/conf.py - -# Include PDF and ePub -formats: all - -python: - version: 3.9 - install: - - method: pip - path: . - extra_requirements: - - docs diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 191dcb2b..30b0d8e4 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -1,30 +1,45 @@ # Correctionlib architecture -This document briefly describes the architecture of correctionlib. -It is meant to provide a good starting point for new contributors to find their way around the codebase. -It assumes some familiarity with correctionlib as a user. +This document briefly describes the architecture of correctionlib. It is meant +to provide a good starting point for new contributors to find their way around +the codebase. It assumes some familiarity with correctionlib as a user. ## Python modules - `schemav2` module: Pydantic models for correctionlib's data structures - - `CorrectionSet` is a list of `Correction`s - - `Correction` represents a single correction. Its `data` attribute is of `Content` type and represents the root node of the computation graph for this correction. Corrections also have a list of inputs as well as one output of type `Variable` (basically a pair of a name and a type, int/float/string) and - - `Content` is the type of a node in the computation graph of a `Correction`. It's a `Union` of the various types of corrections available: `Binning`, `MultiBinning`, `Category`, `Formula`, `FormulaRef`, `Transform`, `HashPRNG`, float -- `highlevel` module: user-facing types (`correctionlib.Correction` resolves to `correctionlib.highlevel.Correction`, etc.) - - `CorrectionSet` is a list of `Correction`s (same as in `schemav2` but focus is on user API rather than defining the schema/structure of the corrections) - - `Correction` and `CompoundCorrection` wrap the corresponding C++ evaluator and expose the `evaluate` method -- `_core` module: a small module that contains the Python facades for the corresponding C++ types, in `__init__.pyi`. - - types are `CorrectionSet`, `Correction`, `CompoundCorrection` and `Variable` - - the bindings are declared in `src/python.cc` + - `CorrectionSet` is a list of `Correction`s + - `Correction` represents a single correction. Its `data` attribute is of + `Content` type and represents the root node of the computation graph for + this correction. Corrections also have a list of inputs as well as one + output of type `Variable` (basically a pair of a name and a type, + int/float/string) and + - `Content` is the type of a node in the computation graph of a `Correction`. + It's a `Union` of the various types of corrections available: `Binning`, + `MultiBinning`, `Category`, `Formula`, `FormulaRef`, `Transform`, + `HashPRNG`, float +- `highlevel` module: user-facing types (`correctionlib.Correction` resolves to + `correctionlib.highlevel.Correction`, etc.) + - `CorrectionSet` is a list of `Correction`s (same as in `schemav2` but focus + is on user API rather than defining the schema/structure of the corrections) + - `Correction` and `CompoundCorrection` wrap the corresponding C++ evaluator + and expose the `evaluate` method +- `_core` module: a small module that contains the Python facades for the + corresponding C++ types, in `__init__.pyi`. + - types are `CorrectionSet`, `Correction`, `CompoundCorrection` and `Variable` + - the bindings are declared in `src/python.cc` ## C++ sources -`include/correction.h` and `src/correction.cc` contain the the C++ types that perform the actual computations: +`include/correction.h` and `src/correction.cc` contain the the C++ types that +perform the actual computations: - a `Variable` type with a name and a type (string, integer, real) - a `CorrectionSet` builds a list of `Corrections` - the `Correction` type, which builds a compute graph of correction nodes -- types for the different types of nodes in a correction's compute graph, e.g. `Binning`, `Formula`, each with its `evaluate` method. They are constructed by deserializing a JSON object. `Formula::Formula`, for example, parses a `TFormula` expression in the JSON and builds the corresponding `FormulaAST` +- types for the different types of nodes in a correction's compute graph, e.g. + `Binning`, `Formula`, each with its `evaluate` method. They are constructed by + deserializing a JSON object. `Formula::Formula`, for example, parses a + `TFormula` expression in the JSON and builds the corresponding `FormulaAST` ## Typical call sequence to evaluate a correction @@ -32,14 +47,27 @@ It assumes some familiarity with correctionlib as a user. ## Building a Correction object -In short, the C++ correction objects that perform the actual correction evaluations are constructed from the JSON representations of the Pydantic types defined in `schemav2`. +In short, the C++ correction objects that perform the actual correction +evaluations are constructed from the JSON representations of the Pydantic types +defined in `schemav2`. Let's say the user calls `schemav2.Correction.to_evaluator`. This: + - constructs a `schemav2.CorrectionSet` (the pydantic model) -- constructs a `highlevel.CorrectionSet` from it and immediately extracts the right `highlevel.Correction` from it, returning it +- constructs a `highlevel.CorrectionSet` from it and immediately extracts the + right `highlevel.Correction` from it, returning it + +The actual construction of the internal C++ correction evaluators happens in the +construction of the `highlevel.CorrectionSet`, which converts the Pydantic +`CorrectionSet` to JSON and uses it to construct a `_core.CorrectionSet` (using +`CorrectionSet.from_string`) -The actual construction of the internal C++ correction evaluators happens in the construction of the `highlevel.CorrectionSet`, which converts the Pydantic `CorrectionSet` to JSON and uses it to construct a `_core.CorrectionSet` (using `CorrectionSet.from_string`) -- `_core.CorrectionSet.from_string` constructs a rapidjson JSONObject and calls `CorrectionSet(const JSONObject &)` -- then for each object in JSONObject it constructs a Correction (`Correction(const JSONObject&)`), and puts it in `CorrectionSet::corrections_` -- `Correction::Correction(const JSONObject&)` sets `data_` to the output of `resolve_content`, passing the json -- `resolve_content` (defined in correction.cc) constructs the appropriate type depending on the JSON input (if/else-ing over the known correction types) +- `_core.CorrectionSet.from_string` constructs a rapidjson JSONObject and calls + `CorrectionSet(const JSONObject &)` +- then for each object in JSONObject it constructs a Correction + (`Correction(const JSONObject&)`), and puts it in + `CorrectionSet::corrections_` +- `Correction::Correction(const JSONObject&)` sets `data_` to the output of + `resolve_content`, passing the json +- `resolve_content` (defined in correction.cc) constructs the appropriate type + depending on the JSON input (if/else-ing over the known correction types) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index fb3f38e7..5abfe68a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,11 +1,15 @@ -The layout of this package was initially generated using the [scikit-hep/cookie][cookie] package -which follows the [Scikit-HEP Developer][skhep-dev-intro] recommendations for modern "dual-stack" -python plus C++ packages. Thanks goes to Henry Schreiner (@henryiii) for putting together these -recommendations and examples. +The layout of this package was initially generated using the +[scikit-hep/cookie][cookie] package which follows the [Scikit-HEP +Developer][skhep-dev-intro] recommendations for modern "dual-stack" python plus +C++ packages. Thanks goes to Henry Schreiner (@henryiii) for putting together +these recommendations and examples. [cookie]: https://github.com/scikit-hep/cookie [skhep-dev-intro]: https://scikit-hep.org/developer/intro +A detailed overview of the architecture of this package is available in +[ARCHITECTURE.md](./ARCHITECTURE.md). + # Setting up a development environment You can set up a development environment by running: @@ -23,21 +27,21 @@ uv sync --no-editable source .venv/bin/activate ``` -The `--no-editable` flag is needed to avoid installing the package in editable mode, -as the paths to the library and include files are not correctly set up for editable installs, -preventing C++ compilation. +The `--no-editable` flag is needed to avoid installing the package in editable +mode, as the paths to the library and include files are not correctly set up for +editable installs, preventing C++ compilation. # Post setup -You should prepare pre-commit, which will help you by checking that commits -pass required checks: +You should prepare pre-commit, which will help you by checking that commits pass +required checks: ```bash pre-commit install # Will install a pre-commit hook into the git repo ``` -You can also/alternatively run `pre-commit run` (changes only) or `pre-commit -run --all-files` to check even without installing the hook. +You can also/alternatively run `pre-commit run` (changes only) or +`pre-commit run --all-files` to check even without installing the hook. # Testing @@ -49,7 +53,8 @@ pytest # Building docs -From inside your environment with the `docs` extra installed (i.e. `pip install .[docs]`), run: +From inside your environment with the `docs` extra installed (i.e. +`pip install .[docs]`), run: ```bash cd docs @@ -58,10 +63,13 @@ make ``` # Conversion routines + The generic conversion routines require the `convert` extra to be installed. # Maintainer notes + A nice commit summary can be generated from the main branch via: + ```bash git log --pretty="format: - %s" $(git describe --tags --abbrev=0)..HEAD ``` diff --git a/README.md b/README.md index 9e237ec9..c0260491 100644 --- a/README.md +++ b/README.md @@ -11,11 +11,12 @@ [![GitHub Discussion][github-discussions-badge]][github-discussions-link] ## Introduction -The purpose of this library is to provide a well-structured JSON data format for a -wide variety of ad-hoc correction factors encountered in a typical HEP analysis and -a companion evaluation tool suitable for use in C++ and python programs. -Here we restrict our definition of correction factors to a class of functions with -scalar inputs that produce a scalar output. + +The purpose of this library is to provide a well-structured JSON data format for +a wide variety of ad-hoc correction factors encountered in a typical HEP +analysis and a companion evaluation tool suitable for use in C++ and python +programs. Here we restrict our definition of correction factors to a class of +functions with scalar inputs that produce a scalar output. In python, the function signature is: @@ -25,71 +26,84 @@ def f(*args: str | int | float) -> float: ``` In C++, the evaluator implements this currently as: + ```cpp double Correction::evaluate(const std::vector>& values) const; ``` The supported function classes include: - * multi-dimensional binned lookups; - * binned lookups pointing to multi-argument formulas with a restricted - math function set (`exp`, `sqrt`, etc.); - * categorical (string or integer enumeration) maps; - * input transforms (updating one input value in place); and - * compositions of the above. +- multi-dimensional binned lookups; +- binned lookups pointing to multi-argument formulas with a restricted math + function set (`exp`, `sqrt`, etc.); +- categorical (string or integer enumeration) maps; +- input transforms (updating one input value in place); and +- compositions of the above. -Each function type is represented by a "node" in a call graph and holds all -of its parameters in a JSON structure, described by the JSON schema. -Possible future extension nodes might include weigted sums (which, when composed with -the others, could represent a BDT) and perhaps simple MLPs. +Each function type is represented by a "node" in a call graph and holds all of +its parameters in a JSON structure, described by the JSON schema. Possible +future extension nodes might include weigted sums (which, when composed with the +others, could represent a BDT) and perhaps simple MLPs. The tool should provide: - * standardized, versioned [JSON schemas](https://json-schema.org/); - * forward-porting tools (to migrate data written in older schema versions); and - * a well-optimized C++ evaluator and python bindings (with numpy vectorization support). +- standardized, versioned [JSON schemas](https://json-schema.org/); +- forward-porting tools (to migrate data written in older schema versions); and +- a well-optimized C++ evaluator and python bindings (with numpy vectorization + support). This tool will definitely not provide: - * support for `TLorentzVector` or other object-type inputs (such tools should be written - as a higher-level tool depending on this library as a low-level tool) +- support for `TLorentzVector` or other object-type inputs (such tools should be + written as a higher-level tool depending on this library as a low-level tool) -Formula support currently includes a mostly-complete subset of the ROOT library `TFormula` class, -and is implemented in a threadsafe standalone manner. The parsing grammar is formally defined -and parsed through the use of a header-only [PEG parser library](https://github.com/yhirose/cpp-peglib). -The supported features mirror CMSSW's [reco::formulaEvaluator](https://github.com/cms-sw/cmssw/pull/11516) -and fully passes the test suite for that utility with the purposeful exception of the `TMath::` namespace. -The python bindings may be able to call into [numexpr](https://numexpr.readthedocs.io/en/latest/user_guide.html), -though, due to the tree-like structure of the corrections, it may prove difficult to exploit vectorization -at levels other than the entrypoint. +Formula support currently includes a mostly-complete subset of the ROOT library +`TFormula` class, and is implemented in a threadsafe standalone manner. The +parsing grammar is formally defined and parsed through the use of a header-only +[PEG parser library](https://github.com/yhirose/cpp-peglib). The supported +features mirror CMSSW's +[reco::formulaEvaluator](https://github.com/cms-sw/cmssw/pull/11516) and fully +passes the test suite for that utility with the purposeful exception of the +`TMath::` namespace. The python bindings may be able to call into +[numexpr](https://numexpr.readthedocs.io/en/latest/user_guide.html), though, due +to the tree-like structure of the corrections, it may prove difficult to exploit +vectorization at levels other than the entrypoint. -Detailed instructions for installing and using this package are provided in the [documentation][rtd-link]. +Detailed instructions for installing and using this package are provided in the +[documentation][rtd-link]. ## Creating new corrections -A demo/tutorial of the features is available in the [documentation][rtd-link] and also available interactively -on [binder](https://mybinder.org/v2/gh/cms-nanoAOD/correctionlib/HEAD?labpath=binder%2Fcorrectionlib_tutorial.ipynb) +A demo/tutorial of the features is available in the [documentation][rtd-link] +and also available interactively on +[binder](https://mybinder.org/v2/gh/cms-nanoAOD/correctionlib/HEAD?labpath=binder%2Fcorrectionlib_tutorial.ipynb) -The `correctionlib.schemav2` module provides a helpful framework for defining correction objects -and `correctionlib.convert` includes select conversion routines for common types. Nodes can be type-checked as they are -constructed using the [parse_obj](https://pydantic-docs.helpmanual.io/usage/models/#helper-functions) +The `correctionlib.schemav2` module provides a helpful framework for defining +correction objects and `correctionlib.convert` includes select conversion +routines for common types. Nodes can be type-checked as they are constructed +using the +[parse_obj](https://pydantic-docs.helpmanual.io/usage/models/#helper-functions) class method or by directly constructing them using keyword arguments. ## Developing -See CONTRIBUTING.md - -[actions-badge]: https://github.com/cms-nanoAOD/correctionlib/workflows/CI/badge.svg -[actions-link]: https://github.com/cms-nanoAOD/correctionlib/actions -[black-badge]: https://img.shields.io/badge/code%20style-black-000000.svg -[black-link]: https://github.com/psf/black -[conda-badge]: https://img.shields.io/conda/vn/conda-forge/correctionlib.svg -[conda-link]: https://github.com/conda-forge/correctionlib-feedstock -[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github -[github-discussions-link]: https://github.com/cms-nanoAOD/correctionlib/discussions -[gitter-badge]: https://badges.gitter.im/https://github.com/cms-nanoAOD/correctionlib/community.svg -[gitter-link]: https://gitter.im/https://github.com/cms-nanoAOD/correctionlib/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge -[pypi-link]: https://pypi.org/project/correctionlib/ -[pypi-platforms]: https://img.shields.io/pypi/pyversions/correctionlib -[pypi-version]: https://badge.fury.io/py/correctionlib.svg -[rtd-badge]: https://github.com/cms-nanoAOD/correctionlib/actions/workflows/docs.yml/badge.svg -[rtd-link]: https://cms-nanoAOD.github.io/correctionlib/ + +See [CONTRIBUTING.md](./CONTRIBUTING.md) for details on setting up a development +environment, testing, and building the documentation. + +[actions-badge]: + https://github.com/cms-nanoAOD/correctionlib/workflows/CI/badge.svg +[actions-link]: https://github.com/cms-nanoAOD/correctionlib/actions +[black-badge]: https://img.shields.io/badge/code%20style-black-000000.svg +[black-link]: https://github.com/psf/black +[conda-badge]: https://img.shields.io/conda/vn/conda-forge/correctionlib.svg +[conda-link]: https://github.com/conda-forge/correctionlib-feedstock +[github-discussions-badge]: + https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github +[github-discussions-link]: + https://github.com/cms-nanoAOD/correctionlib/discussions +[pypi-link]: https://pypi.org/project/correctionlib/ +[pypi-platforms]: https://img.shields.io/pypi/pyversions/correctionlib +[pypi-version]: https://badge.fury.io/py/correctionlib.svg +[rtd-badge]: + https://github.com/cms-nanoAOD/correctionlib/actions/workflows/docs.yml/badge.svg +[rtd-link]: https://cms-nanoAOD.github.io/correctionlib/ diff --git a/binder/correctionlib_tutorial.ipynb b/binder/correctionlib_tutorial.ipynb index bb379cdc..44089af5 100644 --- a/binder/correctionlib_tutorial.ipynb +++ b/binder/correctionlib_tutorial.ipynb @@ -168,7 +168,7 @@ { "data": { "text/plain": [ - "array([1.1 , 1.1 , 1.1 , 1.1 , 1.1 , 1.1 , 1.06, 1.1 , 1.08, 1.06])" + "array([1.08, 1.1 , 1.1 , 1.1 , 1.1 , 1.06, 1.1 , 1.1 , 1.1 , 1.06])" ] }, "execution_count": 5, @@ -178,6 +178,7 @@ ], "source": [ "import numpy as np\n", + "\n", "ptvals = np.random.exponential(15.0, size=10)\n", "\n", "ceval[\"ptweight\"].evaluate(ptvals, \"nominal\")" @@ -266,7 +267,9 @@ " inputs=[\n", " cs.Variable(name=\"pt\", type=\"real\", description=\"Muon transverse momentum\"),\n", " ],\n", - " output=cs.Variable(name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"),\n", + " output=cs.Variable(\n", + " name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"\n", + " ),\n", " data=1.1,\n", ")\n", "corr" @@ -277,7 +280,7 @@ "id": "7f07d14a", "metadata": {}, "source": [ - "The resulting object can be manipulated in-place as needed. Note that this correction object is not an evluator instance as we saw before. We can convert from the schema to an evaluator with the `.to_evaluator()` function:" + "The resulting object can be manipulated in-place as needed. Note that this correction object is not an evaluator instance as we saw before. We can convert from the schema to an evaluator with the `.to_evaluator()` function:" ] }, { @@ -422,8 +425,12 @@ "ptweight = cs.Correction(\n", " name=\"ptweight\",\n", " version=1,\n", - " inputs=[cs.Variable(name=\"pt\", type=\"real\", description=\"Muon transverse momentum\")],\n", - " output=cs.Variable(name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"),\n", + " inputs=[\n", + " cs.Variable(name=\"pt\", type=\"real\", description=\"Muon transverse momentum\")\n", + " ],\n", + " output=cs.Variable(\n", + " name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"\n", + " ),\n", " data=cs.Binning(\n", " nodetype=\"binning\",\n", " input=\"pt\",\n", @@ -479,11 +486,11 @@ "
📈 phimod (v1)\n",
        "Phi-dependent tracking efficiency, or something?\n",
        "Node counts: Category: 1, Formula: 2\n",
-       "╭──────────── â–ķ input ────────────â•Ū ╭──── â–ķ input ────â•Ū\n",
-       "│ phi (real)                      │ │ q (int)         │\n",
-       "│ No description                  │ │ Particle charge │\n",
-       "│ Range: [-inf, inf), overflow ok │ │ Values: -1, 1   │\n",
-       "╰─────────────────────────────────â•Ŋ ╰─────────────────â•Ŋ\n",
+       "╭───────── â–ķ input ──────────â•Ū ╭──── â–ķ input ────â•Ū\n",
+       "│ phi (real)                 │ │ q (int)         │\n",
+       "│ No description             │ │ Particle charge │\n",
+       "│ Range: unused, overflow ok │ │ Values: -1, 1   │\n",
+       "╰────────────────────────────â•Ŋ ╰─────────────────â•Ŋ\n",
        "╭───────── ◀ output ──────────â•Ū\n",
        "│ weight (real)               │\n",
        "│ Multiplicative event weight │\n",
@@ -494,11 +501,11 @@
        "📈 \u001b[1mphimod\u001b[0m \u001b[1m(\u001b[0mv1\u001b[1m)\u001b[0m\n",
        "Phi-dependent tracking efficiency, or something?\n",
        "Node counts: \u001b[1mCategory\u001b[0m: \u001b[1;36m1\u001b[0m, \u001b[1mFormula\u001b[0m: \u001b[1;36m2\u001b[0m\n",
-       "╭──────────── â–ķ input ────────────â•Ū ╭──── â–ķ input ────â•Ū\n",
-       "│ \u001b[1mphi\u001b[0m (real)                      │ │ \u001b[1mq\u001b[0m (int)         │\n",
-       "│ \u001b[3mNo description\u001b[0m                  │ │ Particle charge │\n",
-       "│ Range: [-inf, inf), overflow ok │ │ Values: -1, 1   │\n",
-       "╰─────────────────────────────────â•Ŋ ╰─────────────────â•Ŋ\n",
+       "╭───────── â–ķ input ──────────â•Ū ╭──── â–ķ input ────â•Ū\n",
+       "│ \u001b[1mphi\u001b[0m (real)                 │ │ \u001b[1mq\u001b[0m (int)         │\n",
+       "│ \u001b[3mNo description\u001b[0m             │ │ Particle charge │\n",
+       "│ Range: \u001b[1;31munused\u001b[0m, overflow ok │ │ Values: -1, 1   │\n",
+       "╰────────────────────────────â•Ŋ ╰─────────────────â•Ŋ\n",
        "╭───────── ◀ output ──────────â•Ū\n",
        "│ \u001b[1mweight\u001b[0m (real)               │\n",
        "│ Multiplicative event weight │\n",
@@ -518,7 +525,9 @@
     "        cs.Variable(name=\"phi\", type=\"real\"),\n",
     "        cs.Variable(name=\"q\", type=\"int\", description=\"Particle charge\"),\n",
     "    ],\n",
-    "    output=cs.Variable(name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"),\n",
+    "    output=cs.Variable(\n",
+    "        name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"\n",
+    "    ),\n",
     "    data=cs.Category(\n",
     "        nodetype=\"category\",\n",
     "        input=\"q\",\n",
@@ -541,7 +550,7 @@
     "                    expression=\"(1+0.1*sin(x+0.31))/(1+0.07*sin(x+0.39))\",\n",
     "                ),\n",
     "            ),\n",
-    "        ]\n",
+    "        ],\n",
     "    ),\n",
     ")\n",
     "rich.print(phimod)"
@@ -583,7 +592,7 @@
    "source": [
     "## Converting from histograms\n",
     "\n",
-    "Often one wants to convert a histogram into a correction object. Here we show how to do that using histgrams made with the [hist](https://hist.readthedocs.io/en/latest/) package, but any histogram that respects the [Unified Histogram Interface Plottable](https://uhi.readthedocs.io/en/latest/plotting.html#plotting) protocol (including, for example, ROOT TH1s) should work as well.\n",
+    "Often one wants to convert a histogram into a correction object. Here we show how to do that using histograms made with the [hist](https://hist.readthedocs.io/en/latest/) package, but any histogram that respects the [Unified Histogram Interface Plottable](https://uhi.readthedocs.io/en/latest/plotting.html#plotting) protocol (including, for example, ROOT TH1s) should work as well.\n",
     "\n",
     "Note: some of the conversion utilities require extra packages installed. The simplest way to ensure you have all dependencies is via the `pip install correctionlib[convert]` extras configuration.\n",
     "\n",
@@ -599,7 +608,7 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
      "execution_count": 14,
@@ -608,7 +617,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "
"
       ]
@@ -618,25 +627,26 @@
     }
    ],
    "source": [
-    "import numpy as np\n",
     "import hist\n",
     "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
     "\n",
     "dists = (\n",
-    "    hist.Hist.new\n",
-    "    .StrCat([\"gen1\", \"gen2\"], name=\"dataset\", growth=True)\n",
+    "    hist.Hist.new.StrCat([\"gen1\", \"gen2\"], name=\"dataset\", growth=True)\n",
     "    .Reg(20, 0, 100, name=\"pt\")\n",
     "    .Reg(4, -3, 3, name=\"eta\")\n",
     "    .Weight()\n",
     "    .fill(\n",
     "        dataset=\"gen1\",\n",
-    "        pt=np.random.exponential(scale=10.0, size=10000) + np.random.exponential(scale=10.0, size=10000),\n",
-    "        eta=np.random.normal(scale=1, size=10000)\n",
+    "        pt=np.random.exponential(scale=10.0, size=10000)\n",
+    "        + np.random.exponential(scale=10.0, size=10000),\n",
+    "        eta=np.random.normal(scale=1, size=10000),\n",
     "    )\n",
     "    .fill(\n",
     "        dataset=\"gen2\",\n",
-    "        pt=np.random.exponential(scale=10.0, size=10000) + np.random.exponential(scale=15.0, size=10000),\n",
-    "        eta=np.random.normal(scale=1.1, size=10000)\n",
+    "        pt=np.random.exponential(scale=10.0, size=10000)\n",
+    "        + np.random.exponential(scale=15.0, size=10000),\n",
+    "        eta=np.random.normal(scale=1.1, size=10000),\n",
     "    )\n",
     ")\n",
     "\n",
@@ -662,7 +672,7 @@
     {
      "data": {
       "text/plain": [
-       "ColormeshArtists(pcolormesh=, cbar=, text=[])"
+       "ColormeshArtists(pcolormesh=, cbar=, text=[])"
       ]
      },
      "execution_count": 15,
@@ -671,7 +681,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAG2CAYAAAA0vZ0sAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAMQ9JREFUeJzt3Ql8FdXZ+PHnJiEJERJAlhgIi0U2WYWCQX0FQZGXP0p960upr6SoWC20lFgVrIK4xaUg1KIIooiCIBap4kIRCHzQABJAcUM2TQoERIRAgETunf/nHJrbXAh4bpjJ3Ln5ff0ck5nMnRkyWZ48z1l8lmVZAgAAANgoxs6TAQAAAASZAAAAcASZTAAAANiOIBMAAAC2I8gEAACA7QgyAQAAYDuCTAAAANiOIBMAAAC2I8gEAACA7QgyAQAAUH2DzOeee046duwoycnJumVkZMh777131tcsWLBA2rRpI4mJidKhQwd59913q+x+AQAAqjPPBJlNmjSRxx9/XPLy8mT9+vVy1VVXyfXXXy+ff/55hcd/9NFHMmTIELn11ltl48aNMmjQIN0+++yzKr93AACA6sZnWZYlHlWvXj156qmndCB5qsGDB0txcbEsXrw4uO/SSy+Vzp07y7Rp06r4TgEAAKqXOPEgv9+vS+EqiFRl84rk5uZKVlZWyL5+/frJokWLznrukpIS3coEAgE5cOCAnH/++eLz+Wz6FwAAACepHNrhw4clLS1NYmLsKdweP35cSktLJRLEx8fr7oCRzFNB5ubNm3VQqR5yrVq15M0335R27dpVeGxhYaE0atQoZJ/aVvvPJjs7WyZMmGDrfQMAAHcUFBToLnfnSsUeLZrVksJ9fokEqampsnPnzogOND0VZLZu3Vo2bdokhw4dkjfeeEMyMzNl5cqVZww0K2Ps2LEhGVB1raZNm0rjp8dITE3nHmRy3WJxWkmps4+70wW7xWnrPm3p+DXqfhbr+DVqFDvfS+VwurOZ99oFzv8bkvY6nzHYdVmC49e4cOY3jl9DAgFHT/9DrxbitEMtnK8WBS4+4vg1pAo6odV95zxHz//D/3P+d5LTAsdK5JvfTpTatWvbcj6VwVQB5rd5zSW5trtDWooOB6RZ12/0PRFk2pgabtnyZJDRtWtX+fjjj2XKlCny/PPPVxjh7927N2Sf2lb7zyYhIUG3U6kA08kgMzbphGPnDl4jroaj569xXrw4zclnUCY23vkgM/ZH538LxSY4+ws7Nt75f0NcnPM/yGMTnQ8y42Kc/94QcTbIjKuR6PmvWcVXBT9rqyLIdPp5xCZFRrbODnZ3datV26ebmwLije57nhldXhHVX7J8/8nyVFl92bJlIfuWLl16xj6cAAAAP8VvBSKieYFnyuWqjN2/f39dulYdeefOnSs5OTmyZMkS/fGhQ4dK48aNdZ9KZdSoUXLllVfKxIkTZcCAATJv3jw99dH06dNd/pcAAACvCoilm9v34AWeCTL37dunA8k9e/ZISkqKnphdBZhXX321/nh+fn7I6LGePXvqQPT++++X++67Ty666CI9srx9+/Yu/isAAACqB88EmTNnzjzrx1VW81Q33nijbgAAAHYI6P/cFXD9DqIsyAQAAHCb37J0c/sevMDTA38AAAAQmchkAgAAGGLgjzmCTAAAgDCCTD+jy41QLgcAAIDtyGQCAAAYolxujiATAADAEKPLzVEuBwAAgO3IZAIAABhS06C7PRV6QLyBIBMAAMCQPwJGl/tZuxwAACC6+K2Tze178AL6ZAIAAMB2lMsBAAAM0SfTHEEmAACAoYD4xC8+1+/BCyiXAwAAwHZkMgEAAAwFrJPNTQGPDPwhyAQAADDkj4ByuZ9yOQAAAKorMpkAAACGyGSaI8gEAAAwFLB8urkp4PL1TTG6HAAAALYjkwkAAGCIcrk5gkwAAABDfonRzU1+8QaCTAAAAENWBPTJtOiTCQAAgOqKTCYAAIAh+mSaI8gEAAAw5LdidHOT3yPLSjKFEQAAAGxHJhMAAMBQQHwScDlHFxBvpDIJMgEAAAzRJ9Mc5XIAAADYjkwmAACApwb+WOIFZDIBAADC6pPpfgvHqlWrZODAgZKWliY+n08WLVpk/NoPP/xQ4uLipHPnzhIugkwAAIAoVlxcLJ06dZKpU6eG9bqDBw/K0KFDpU+fPpW6LuVyAAAAQ4EIWLs8EObo8v79++sWrjvuuEN+/etfS2xsbFjZzzIEmQAAAB7sk1lUVBSyPyEhQTc7vPTSS7Jjxw559dVX5ZFHHqnUOSiXAwAAhJHJjISmpKenS0pKSrBlZ2eLHbZu3SpjxozRAabqj1lZZDIBAAA8qKCgQJKTk4PbdmQx/X6/LpFPmDBBWrVqdU7nIsgEAAAwDcIsn25u8v/7+irALB9k2uHw4cOyfv162bhxo4wcOVLvCwQCYlmWzmr+85//lKuuusroXASZAAAAhvwRMPDH7+Cykipo3bx5c8i+Z599VpYvXy5vvPGGtGjRwvhcBJkAAABR7MiRI7Jt27bg9s6dO2XTpk1Sr149adq0qYwdO1Z27dols2fPlpiYGGnfvn3I6xs2bCiJiYmn7f8pBJkAAACGAlaMbm4KhLnijyp/9+7dO7idlZWl32ZmZsqsWbNkz549kp+fb/t9EmQCAABEcbm8V69euk/lmahA82wefPBB3cLFFEYAAACwHZlMAAAAQ4Fyo7vdvAcvIMgEAAAwVH4ydLcEPFKI9sZdAgAAwFPIZAIAAHhq7fIY8QKCTAAAAEMB8enmpoDL1zdFkAkAAGCITKY5b+RbAQAA4ClkMgEAADw1GXuMeAFBJgAAgKGA5dPNTQGXr2/KG6EwAAAAPIVMJgAAQBgTobtdrg54JEdIkAkAAGAoYMXo5qaAR+bJ9MZdAgAAwFPIZAIAABjyi083N/mZjB0AACC6UC43R7kcAAAAtqNcDgAAYMgfAeVqv3gDQSYAAIAhyuXmCDIBAAAM+a0Y3dzkZwojAAAAVFdkMgEAAAxZ4pOAy30yLaYwAgAAiC6Uy80xhREAAABsR7kcAADAUMDy6eamgMvXN0WQCQAAYMgvMbq5ye+RQrQ37hIAAACeQiYTAADAEOVycwSZAAAAhgISo5ubAh4pRHvjLgEAAOApZDIBAAAM+S2fbm7yM7ocAAAgutAn0xyZTAAAAEOWFSMBK8b1e/ACb9wlAAAAPIVMJgAAgCG/+HRzk9/l65siyAQAADAUsNxf1jFgiSdQLgcAAIDtyGQCAAAYCkTAwJ8AA3/st2rVKhk4cKCkpaWJz+eTRYsWnfX4nJwcfdyprbCw0IG7AwAA0S4gvohoTsZPCxculKuvvloaNGggycnJkpGRIUuWLJGoLpcXFxdLp06dZOrUqWG9bsuWLbJnz55ga9iwoWP3CAAA4OX4SQWlKsh89913JS8vT3r37q2D1I0bN0Zvubx///66hUsFlXXq1HHkngAAQPXhxRV/+ocZP02ePDlk+7HHHpN//OMf8vbbb0uXLl2iM5NZWZ07d5YLLrhAR+Uffvih27cDAAA83ifT7VaVAoGAHD58WOrVqxe9mcxwqcBy2rRp0q1bNykpKZEXXnhBevXqJWvXrpVLLrmkwteo41QrU1RUVIV3DAAAYObUGCUhIUE3u/3lL3+RI0eOyP/+7/+G9bqoDjJbt26tW5mePXvK9u3b5emnn5ZXXnmlwtdkZ2fLhAkTTtv/6VWzJbl2rGP3+sSBluK0TYeaOnr+qvjLKial1PFrnPjv445f44dvUhy/hpXgd/T8MSXO//goTrX/h+Wpknc6P+Hc/mtaOH+Nrs7+O5q/9aM47bx/Ofs1q9SYvNPxa1itmjl+jW//29lybfMhX4rTvnmtrXiRHnjj9jyZcvL66enpIfvHjx8vDz74oK3Xmjt3ro6LVLk83DEtUR1kVqR79+6yevXqM3587NixkpWVFfJXwqkPEQAAVE9WJUZ3O3EPSkFBgR79XcbuLOa8efPktttukwULFkjfvn3Dfn21CzI3bdqky+hn4lSqGQAAeJ/KYrqeybROXl8FmOWDTDu99tprcsstt+hAc8CAAZU6h6eCTNUfYNu2bcHtnTt36qBRdURt2rSpzkLu2rVLZs+eHRwd1aJFC7n44ovl+PHjuk/m8uXL5Z///KeL/woAAIDIjZ9UiTwzM1OmTJkiPXr0CM4vXrNmTUlJSYnOIHP9+vV6rqYyZWVt9YmYNWuWngMzPz8/+PHS0lK566679CcuKSlJOnbsKB988EHIOQAAAKJ5xZ/1YcZP06dPlxMnTsiIESN0K1N2fFQGmWpkuGWduXP7qf/we+65RzcAAIBoK5c7FT+pFRPtUC3myQQAAEDV8lQmEwAAwE2VWTvcbm5f3xRBJgAAQBSXy91CuRwAAAC2I5MJAABgiEymOYJMAAAAQwSZ5iiXAwAAwHZkMgEAAAyRyTRHkAkAAGDIioAphCzxBoJMAAAAQ2QyzdEnEwAAALYjkwkAAGCITKY5gkwAAABDBJnmKJcDAADAdmQyAQAADJHJNEeQCQAAYMiyfLq5yXL5+qYolwMAAMB2ZDIBAAAMqYnY3Z6MPeDy9U0RZAIAABiiT6Y5yuUAAACwHZlMAAAAQwz8MUeQCQAAYIhyuTmCTAAAAENkMs3RJxMAAAC2I5MJAAAQRiZTlczdZHlkMnaCTAAAAEOWDvLc/XRZ4g2UywEAAGA7MpkAAABhrLaj/nNTgBV/AAAAogujy81RLgcAAIDtKJcDAAAYUiPLfS6P7g4wuhwAACC6qJHlro8ut8QTKJcDAADAdpTLAQAADDHwxxxBJgAAgCGCTHMEmQAAAIYY+GOOPpkAAACwHZlMAAAAQ4wuN0eQCQAAEFaQ6e48mRZTGAEAAMBtq1atkoEDB0paWpr4fD5ZtGjRT74mJydHLrnkEklISJCWLVvKrFmzwr4ufTIBAADCHF3udgtHcXGxdOrUSaZOnWp0/M6dO2XAgAHSu3dv2bRpk/zxj3+U2267TZYsWRLWdSmXAwAAGFKVarer1VaYx/fv3183U9OmTZMWLVrIxIkT9Xbbtm1l9erV8vTTT0u/fv2Mz0MmEwAAwIOKiopCWklJiS3nzc3Nlb59+4bsU8Gl2h8OgkwAAABDkVQuT09Pl5SUlGDLzs625TkWFhZKo0aNQvapbRXIHjt2zPg8lMsBAAA8WC8vKCiQ5OTk4G41SCeSEGQCAACYqsTAG9v9+/oqwCwfZNolNTVV9u7dG7JPbatr1axZ0/g8lMsBAAAQlJGRIcuWLfvPDhFZunSp3h8OgkwAAIAwV/xxu4XjyJEjeioi1cqmKFLv5+fn6+2xY8fK0KFDg8ffcccdsmPHDrnnnnvkq6++kmeffVZef/11GT16dFjXpVwOAABgqDLzVNot3OuvX79ez3lZJisrS7/NzMzUk6zv2bMnGHAqavqid955RweVU6ZMkSZNmsgLL7wQ1vRFCkEmAABAFOvVq5dYZ0l/VrSaj3rNxo0bz+m6BJkAAACmVBYxQgb+RDqCTAAAAEOV6RNpN7evb4qBPwAAALAdmUwAAAAPTsYe6QgyAQAAonh0uVsolwMAAMB2ZDIBAACisFztNoJMAAAAQ5TLzRFkAgAAmGLgjzH6ZAIAAMB2ZDIBAACMqZHdbo/u9okXEGQCAACYolxujHI5AAAAbEcmEwAAwBSZTGMEmQAAAKbUajtur7hjeaNPJuVyAAAA2I5MJgAAgCHLOtncZHlkxSGCTAAAAFP0yTRGuRwAAAC2I5MJAABgioE/xggyAQAADPmsk81NPvpkAgAARBn6ZBqjTyYAAABsR7kcAADAFH0yjRFkAgAAmKJcboxyOQAAAGxHJhMAAMAUmUxjBJkAAACmCDKrJsj84osvJD8/X0pLS0P2X3fddedyWgAAAHhcpYLMHTt2yC9+8QvZvHmz+Hw+sf69Urt6X/H7/fbeJQAAQCRgdLmzA39GjRolLVq0kH379klSUpJ8/vnnsmrVKunWrZvk5ORU5pQAAACeWfHH7Ra1mczc3FxZvny51K9fX2JiYnS7/PLLJTs7W/7whz/Ixo0b7b9TAAAAeEalMpmqHF67dm39vgo0d+/erd9v1qyZbNmyRZw0depUad68uSQmJkqPHj1k3bp1Zz1+wYIF0qZNG318hw4d5N1333X0/gAAQDUY+ON2i9Ygs3379vLJJ5/o91Wg9+STT8qHH34oDz30kFx44YXilPnz50tWVpaMHz9eNmzYIJ06dZJ+/frpsn1FPvroIxkyZIjceuutOrs6aNAg3T777DPH7hEAAACVDDLvv/9+CQQC+n0VWO7cuVOuuOIKnSWcMmWKY5/XSZMmyfDhw2XYsGHSrl07mTZtmu4T+uKLL1Z4vLqXa6+9Vu6++25p27atPPzww3LJJZfI3/72N8fuEQAARC81xNnt/pg+ieI+mSp7WKZly5by1VdfyYEDB6Ru3brBEeZ2U9Mk5eXlydixY4P7VF/Qvn376j6iFVH7Vebz1HtftGjRGa9TUlKiW5mioiJb7h8AAKA6qVSQecstt+gsYVm/TKVevXpSXFwsv//978+YWTwX+/fv131BGzVqFLJfbasgtyKFhYUVHq/2n4kavDRhwoTT9k880FISS2uIU5rG7xenldR27v6Vz4vSxGk1k0LnZHVCyY/Or1FgxTnfocZX4uyqsSfOE8fFHXX+GkeaOJ8TaPDJCcevkfy1s1+3xxo6+/NDqbv0G8evsXN0B8ev0eyJDY5fIz3vuKPn93Vp5+j5PY0pjIxV6rfQyy+/LMeOHTttv9o3e/Zs8TKVKT106FCwFRQUuH1LAAAgUrg94MeK0oE/qnSsAi81+frhw4f1dln74YcfdJ/Mhg0bOnKjahR7bGys7N27N2S/2k5NTa3wNWp/OMcrCQkJkpycHNIAAAC8bGqYs/NMnjxZWrduLTVr1pT09HQZPXq0HD9+3Lkgs06dOrosrvpdtmrVSvfBLGsqCFRl9BEjRogT4uPjpWvXrrJs2bLgPjX4SG1nZGRU+Bq1v/zxytKlS894PAAAwFl5MJM5P8zZeebOnStjxozRx3/55Zcyc+ZMfY777rsvrOuG1YlnxYoVOot51VVXyd///ncdcJYPAtU8mWlpzvXLU5+gzMxMvbJQ9+7ddZSt+oGq0ebK0KFDpXHjxrpfZdnKRFdeeaVMnDhRBgwYIPPmzZP169fL9OnTHbtHAAAQvSJhxR2fVfnZeRQ1O88777yjx9CoYLKiKSAvu+wy+fWvf623VQZUTQm5du1a54JMFbApasqi/Px8ef7552X79u3yxhtv6ODulVde0ctNqtV/nDB48GD57rvvZNy4cXrwTufOneX9998PDu5R96RGnJfp2bOnjsbVlEsq+r7ooov0yHI1zycAAICXFZ0yA47q8qfauc7Oo+KnV199VZfUVVJvx44dukvkzTffHNb9VWo4osoGqgvddNNNepLzsil/VH/Nxx57zNFVdUaOHKlbRSpaN/3GG2/UDQAA4JxFwsAb6+Qb1VeyPFXefvDBB895dh6VwVSvU0lDVcE+ceKE3HHHHWGXyys1uvyRRx7RqdYZM2ZIjRr/mdZCpVZVrR8AACAqud0X0/pPkKlmwCk/I075bOW5UEk7lTR89tlndVy3cOFCXV5Xi9o4nslU65P/13/912n7U1JS5ODBg5U5JQAAAMJgMgtOZWbneeCBB3TF+rbbbtPbHTp00GNgbr/9dvnzn/8c0jXR9kymuqlt27adtn/16tWOrl0OAADgJteXlLTCG/hTmdl5jh49elogqQJVRZXPHc1kqhFKauS2GpWkpjPavXu37jz6pz/9SUe/AAAAUcmDK/5khTk7z8CBA/WI9C5duug5NVViUcV3an9ZsOlYkKmGu6souE+fPjraVaVzNZpJBZlqWUkAAICoFEEDf5yanUfNyqOSiOrtrl27pEGDBjrAfPTRRyUclQoy1YVVTf7uu+/W0e2RI0ekXbt2UqtWrcqcDgAAAA4KZ3aeuLg4PVJdtXNRqSCzfJ1fBZcAAADVgRcnY3fLOQWZAAAA1YoHy+VuqdTocgAAAOBsyGQCAACYioByubh9fUMEmQAAAKYolxujXA4AAADbkckEAAAwRSbTGEEmAACAIaYwMke5HAAAALYjyAQAAIDtKJcDAACYok+mMYJMAAAAQ/TJNEe5HAAAALYjkwkAABCFK+64jSATAADAFH0yjVEuBwAAgO3IZAIAABhi4I85gkwAAABTlMuNUS4HAACA7chkAgAAGKJcbo4gEwAAwBTlcmOUywEAAGA7MpkAAACmyGQaI8gEAAAwRJ9McwSZAAAApshkGqNPJgAAAGxHJhMAAMAUmUxjBJkAAACG6JNpjnI5AAAAbEcmEwAAwBTlcmMEmQAAAIYol5ujXA4AAADbkckEAAAwRbncGEEmAACAKYJMY5TLAQAAYDsymQAAAIZ8/25u8ok3EGQCAACYolxujCATAADAEFMYmaNPJgAAQJSbOnWqNG/eXBITE6VHjx6ybt26sx5/8OBBGTFihFxwwQWSkJAgrVq1knfffTesa5LJBAAAiOJy+fz58yUrK0umTZumA8zJkydLv379ZMuWLdKwYcPTji8tLZWrr75af+yNN96Qxo0by7fffit16tQJ67oEmQAAAOFwO8gM06RJk2T48OEybNgwva2CzXfeeUdefPFFGTNmzGnHq/0HDhyQjz76SGrUqKH3qSxouCiXAwAAeFBRUVFIKykpqTArmZeXJ3379g3ui4mJ0du5ubkVnvett96SjIwMXS5v1KiRtG/fXh577DHx+/1h3R9BJgAAQJgDf9xuSnp6uqSkpARbdna2nGr//v06OFTBYnlqu7CwUCqyY8cOXSZXr1P9MB944AGZOHGiPPLIIxIOyuUAAAAe7JNZUFAgycnJwd1qgI4dAoGA7o85ffp0iY2Nla5du8quXbvkqaeekvHjxxufhyATAADAg5KTk0OCzIrUr19fB4p79+4N2a+2U1NTK3yNGlGu+mKq15Vp27atznyq8nt8fLzR/VEuBwAAMOR2mdxXrlxuQgWEKhO5bNmykEyl2lb9Lity2WWXybZt2/RxZb7++msdfJoGmApBJgAAQLjlcrdbGNT0RTNmzJCXX35ZvvzyS7nzzjuluLg4ONp86NChMnbs2ODx6uNqdPmoUaN0cKlGoquBP2ogUDgolwMAAESxwYMHy3fffSfjxo3TJe/OnTvL+++/HxwMlJ+fr0ecl1EDipYsWSKjR4+Wjh076nkyVcB57733hnVdgkwAAIAoX1Zy5MiRulUkJyfntH2qlL5mzRo5FwSZAAAAHhxdHukIMgEAAEwRZBpj4A8AAABsRyYTAAAgyvtkuoEgEwAAwBTlcmOUywEAAGA7MpkAAACGfJalm5t8Ll/fFEEmAACAKcrlxiiXAwAAwHZkMgEAAAwxutwcQSYAAIApyuXGKJcDAADAdmQyAQAADFEuN0eQCQAAYIpyuTGCTAAAAENkMs3RJxMAAAC2I5MJAABginK5MYJMAACAMEvm+GmUywEAAGA7MpkAAACmLOtkc5PljVQqQSYAAIAhRpebo1wOAAAA25HJBAAAMMXocmMEmQAAAIZ8gZPNTT6Xr2+KcjkAAABsRyYTAADAFOXy6MtkPvroo9KzZ09JSkqSOnXqGL3mN7/5jfh8vpB27bXXOn6vAAAgukeXu928wDOZzNLSUrnxxhslIyNDZs6cafw6FVS+9NJLwe2EhASH7hAAAEQ95smMviBzwoQJ+u2sWbPCep0KKlNTUx26KwAAAHi6XF5ZOTk50rBhQ2ndurXceeed8v3335/1+JKSEikqKgppAAAAittlch/l8sigSuU33HCDtGjRQrZv3y733Xef9O/fX3JzcyU2NrbC12RnZwezpuUlxJyQBAdD8kc3/7c4rUPqHkfP//niVuI0f6Ljl5DY485fo94B569xIKPU0fPH5ceL0xrlOf8w4opKHL9GSYMkx69Rd+uPjp5/92U1xGmJ37dw/BrpHxx1/Bo7X3X+ZyFcxMAfb2Qyx4wZc9rAnFPbV199Venz/+pXv5LrrrtOOnToIIMGDZLFixfLxx9/rLObZzJ27Fg5dOhQsBUUFFT6+gAAANWVq30y77rrLj0C/GwuvPBC266nzlW/fn3Ztm2b9OnT54x9OBkcBAAAKhIJ5Wofo8t/WoMGDXSrKv/61790n8wLLrigyq4JAACiCKPLo2/gT35+vmzatEm/9fv9+n3Vjhw5EjymTZs28uabb+r31f67775b1qxZI998840sW7ZMrr/+emnZsqX069fPxX8JAABA9PPMFEbjxo2Tl19+ObjdpUsX/XbFihXSq1cv/f6WLVt0P0pFDez59NNP9WsOHjwoaWlpcs0118jDDz9MORwAAFQK5fIoDDLV/Jg/NUempVLY/1azZk1ZsmRJFdwZAACoNhhdHn3lcgAAAHgHQSYAAIAhtydh91VydPvUqVOlefPmkpiYKD169JB169YZvW7evHl6Skk1FWS4CDIBAABMBazIaGGYP3++ZGVlyfjx42XDhg3SqVMnPQh63759Z32dGjj9pz/9Sa644gqpDIJMAACAcPtkut3CMGnSJBk+fLgMGzZM2rVrJ9OmTZOkpCR58cUXz/gaNZPPTTfdpFdBrOyc5QSZAAAAHlRUVBTSSkpOXya3tLRU8vLypG/fvsF9MTExelsts30mDz30kDRs2FBuvfXWSt8fQSYAAIAhXyT0y5ST0tPTJSUlJdiys7NPu9/9+/frrGSjRo1C9qvtwsLCCv+Nq1evlpkzZ8qMGTOqxxRGAAAArougFX8KCgokOTk5uNuOZbEPHz4sN998sw4w1VLc54IgEwAAwIOSk5NDgsyKqEBRLVCzd+/ekP1qOzU19bTjt2/frgf8DBw4MLgvEAjot3FxcXrhm5/97GdG90e5HAAAwJDXpjCKj4+Xrl276uW1yweNajsjI+O049US3Zs3bw4u363addddJ71799bvqxK9KTKZAAAAUbziT1ZWlmRmZkq3bt2ke/fuMnnyZCkuLtajzZWhQ4dK48aNdZ9ONY9m+/btQ15fp04d/fbU/T+FIBMAACCKDR48WL777jsZN26cHuzTuXNnef/994ODgfLz8/WIc7sRZAIAABjyWZZubvJV4vojR47UrSI5OTlnfe2sWbOkMggyAQAATKkxMCfHwbgnIJ7AwB8AAADYjkwmAABAlJfL3UCQCQAAEMWjy91CkAkAAODBFX8iHX0yAQAAYDsymQAAAIbCXXHHCW5f3xRBJgAAgCnK5cYolwMAAMB2ZDIBAAAM+QInm5t8HpmMnSATAADAFOVyY5TLAQAAYDsymQAAAKaYjN0YQSYAAIAhlpU0R7kcAAAAtiOTCQAAYIqBP8YIMgEAAMLpk+n2FEKWeAJBJgAAgCH6ZJqjTyYAAABsRyYTAAAgrCmMXK5XW+IJBJkAAACmGPhjjHI5AAAAbEcmEwAAwJQaWe5z+dMVEE8gyAQAADDE6HJzlMsBAABgOzKZAAAAphj4Y4wgEwAAwBRBpjHK5QAAALAdmUwAAABTZDKNEWQCAACYYgojYwSZAAAAhpjCyBx9MgEAAGA7MpkAAACm6JNpjCATAADAVMBSNXP378EDKJcDAADAdmQyAQAATFEuN0aQCQAAYMw6GWi6yhIvoFwOAAAA2xFkAgAAhFsud7uFaerUqdK8eXNJTEyUHj16yLp168547IwZM+SKK66QunXr6ta3b9+zHn8mBJkAAADhjOyOhBaG+fPnS1ZWlowfP142bNggnTp1kn79+sm+ffsqPD4nJ0eGDBkiK1askNzcXElPT5drrrlGdu3aFc5lCTIBAACi2aRJk2T48OEybNgwadeunUybNk2SkpLkxRdfrPD4OXPmyO9+9zvp3LmztGnTRl544QUJBAKybNmysK7LwB8AAABTVuBkc5N18vpFRUUhuxMSEnQrr7S0VPLy8mTs2LHBfTExMboErrKUJo4ePSo//vij1KtXL6zbpFwOAABgKoL6ZKanp0tKSkqwZWdnn3a7+/fvF7/fL40aNQrZr7YLCwuN/sn33nuvpKWl6cA0HGQyAQAATOn+kJGx4k9BQYEkJycHd5+axbTD448/LvPmzdP9NNWgoXAQZAIAAHhQcnJySJBZkfr160tsbKzs3bs3ZL/aTk1NPetr//KXv+gg84MPPpCOHTuGfX+UywEAAEx5bAqj+Ph46dq1a8ignbJBPBkZGWd83ZNPPikPP/ywvP/++9KtW7dKfX2QyQQAADClq+Uul8ut8A5X0xdlZmbqYLF79+4yefJkKS4u1qPNlaFDh0rjxo2DfTqfeOIJGTdunMydO1fPrVnWd7NWrVq6mSLIBAAAiGKDBw+W7777TgeOKmBUUxOpDGXZYKD8/Hw94rzMc889p0el//KXvww5j5pn88EHHzS+LkEmAACAqUquuGOrSlx/5MiRulVEDeop75tvvhE7EGQCAACYCqg5KgMRcA+Rj4E/AAAAsB2ZTAAAgCgvl7uBIBMAAMAUQaYxyuUAAACwHZlMAAAADy4rGekIMgEAAAxZVkA3N1kuX98UQSYAAEA4fTLdziRa3shk0icTAAAAtiOTCQAAEFYWkUymCYJMAACAcFbb8bncJ9LyRp9MyuUAAACwHZlMAAAAU5TLjRFkAgAAGLICAbFcLpdblMsBAABQXZHJBAAAMEW53BhBJgAAgCk1EbuPKYxMMLocAAAAtiOTCQAAEFa53O15Mi3xAoJMAAAAQ1bAEsvlcrlFkAkAABBl9PRBbmcyA+IFnumTed1110nTpk0lMTFRLrjgArn55ptl9+7dZ33N8ePHZcSIEXL++edLrVq15H/+539k7969VXbPAAAA1ZVngszevXvL66+/Llu2bJG///3vsn37dvnlL3951teMHj1a3n77bVmwYIGsXLlSB6U33HBDld0zAACIwnJ5BDQv8EyfTBUwlmnWrJmMGTNGBg0aJD/++KPUqFHjtOMPHTokM2fOlLlz58pVV12l97300kvStm1bWbNmjVx66aVVev8AACAKUC6PviCzvAMHDsicOXOkZ8+eFQaYSl5eng5A+/btG9zXpk0bXXLPzc09Y5BZUlKiW/lgVTl+5IQ4yX/0uDjtx+JSR8/vL3H+3+B3/Arqi8D5S/idfRRa4JjTz9v5PkEnThyPiodx4oRnikZn5D/u/HffiRM/On4NXxVcw3/UG/3lol3gWIkjg2ROyI8iLicST6h78ALLQ+655x4rKSlJPVrr0ksvtfbv33/GY+fMmWPFx8eftv/nP/+5Ps+ZjB8/Xp+fxueArwG+Bvga4GuArwHvfw1s377dlhjk2LFjVmpqquv/Hvl3U/ei7imS+dT/3ApwVcn7iSeeOOsxX375pc5AKvv379dZzG+//VYmTJggKSkpsnjxYvH5fKe9TpXJhw0bFpKVVLp37677d57puqdmMg8ePKjL8/n5+fp6cE9RUZGkp6dLQUGBJCcn8yh4FuB7I+LwcypyqEqkql7+8MMPUqdOHVvOqQYUl5ZWQSnKQHx8vB4MHclcLZffdddd8pvf/Oasx1x44YXB9+vXr69bq1atdN9KFXCo/pUZGRmnvS41NVV/IaggsfwXlxpdrj52JgkJCbqdSgWYBDaRQT0HnkVk4FlEFp5H5OBZRI6YGPu6q6igLtIDu0jiapDZoEED3SojEDjZ5+XUTGWZrl276v6ay5Yt01MXKWpkuspIVhSUAgAAoJoN/Fm7dq18/PHHcvnll0vdunX19EUPPPCA/OxnPwsGjLt27ZI+ffrI7NmzdUlcZR5vvfVWycrKknr16um/Kn//+9/r4xlZDgAA4CxPBJlJSUmycOFCGT9+vBQXF+vJ2K+99lq5//77g6VtNZJcZSqPHj0afN3TTz+t0+Qqk6kynv369ZNnn302rGur86vrVlRCR9XiWUQOnkVk4XlEDp5F5OBZuM/VgT8AAACITt6fvA0AAAARhyATAAAABJkAAACIfGQyAQAAYDuCzLOYOnWqNG/eXE+82qNHD1m3bp39TwAhsrOz5ec//7nUrl1bGjZsKIMGDdKzBpy64sKIESPk/PPPl1q1aunZA9Qk+3DW448/rlfX+uMf/8izcImaqu3//u//9Nd+zZo1pUOHDrJ+/frgx9U4znHjxukZONTH+/btK1u3bnXrdqOW3+/X0+i1aNFCf57VdHoPP/xwyBrZPAtnrFq1SgYOHChpaWn659GiRYtCPm7yeVcrB9500016akO1WIua7vDIkSMO3XH1RpB5BvPnz9dzbKrpizZs2CCdOnXSUyDt27evap9QNbNy5UodQKqVnJYuXaqnprrmmmv01FVlRo8eLW+//bYsWLBAH79792654YYbXL3vaKfmqX3++eelY8eOIft5FlVHLY132WWX6UUm3nvvPfniiy9k4sSJeu7gMk8++aT89a9/lWnTpun5hc877zz9c0v9YQb7qGWJn3vuOfnb3/6mlz5W2+pz/8wzz/AsHKZ+F6jfxyoJVBGT7wEVYH7++ef6d4xamloFrrfffrvTt149ub14eqTq3r27NWLEiOC23++30tLSrOzsbFfvq7rZt2+fSg1YK1eu1NsHDx60atSoYS1YsCB4zJdffqmPyc3NdfFOo9fhw4etiy66yFq6dKl15ZVXWqNGjdL7eRZV695777Uuv/zyM348EAhYqamp1lNPPRXcp55RQkKC9dprr1XRXVYPAwYMsG655ZaQfTfccIN100036fd5FlVD/dx/8803g9smn/cvvvhCv+7jjz8OHvPee+9ZPp/P2rVrVxXdefVBJrMCas3zvLw8nWYvoyZ1V9u5ublV+TdAtXfo0CH9OVCrNinquajsZvln06ZNG2natCnPxiEqszxgwICQzznPouq99dZb0q1bN7nxxht1V5IuXbrIjBkzgh/fuXOnFBYWhjwntfKZ6urDzy179ezZUy9Z/PXXX+vtTz75RFavXi39+/fnWbjI5HtAvVUlcvW9VEYdr37Hq8wnquGKP1Vt//79us9No0aNQvar7a+++sq1+6pu1Pr0qv+fKhG2b99e71M/QOLj4/UPiVOfjfoY7DVv3jzdXUSVy0/Fs6haO3bs0CVa1Y3nvvvu08/kD3/4g/5+yMzMDH79V/Rzi+8Ne40ZM0aKior0H7ixsbH698Wjjz6qy7AKz8IdJp939Vb9kVZeXFycTmTwfWI/gkxEdAbts88+0xkCVL2CggIZNWqU7rekBr/B/T+6VPblscce09sqk6m+P1TfMxVkouq8/vrrMmfOHJk7d65cfPHFsmnTJv0HsRqMwrMA/oNyeQXq16+v/zo9dcSy2k5NTa3oJbDZyJEjdYfsFStWSJMmTYL71edfdWc4ePAgz8ZhqmuCGuh2ySWX6L/0VVMDrVSnevW+yg7wLKqOGi3brl27kH1t27aV/Px8/X7ZzyZ+bjnv7rvv1tnMX/3qV3qE/80336wHwanZMXgW7jH5HlBvTx3Ae+LECT3inN/v9iPIrIAqP3Xt2lX3uSmfRVDbGRkZDjwGlFF9uVWA+eabb8ry5cv1FCHlqeeiRteWfzZqiiP1i5ZnY68+ffrI5s2bdZamrKlMmioJlr3Ps6g6qtvIqdN5qT6BzZo10++r7xX1S7L894Yq6ap+Znxv2Ovo0aO6D195KjGhfk/wLNxj8j2g3qokhfojuoz6XaOeneq7CZu5PfIoUs2bN0+PSJs1a5YejXb77bdbderUsQoLC92+tah25513WikpKVZOTo61Z8+eYDt69GjwmDvuuMNq2rSptXz5cmv9+vVWRkaGbnBe+dHlPIuqtW7dOisuLs569NFHra1bt1pz5syxkpKSrFdffTV4zOOPP65/Tv3jH/+wPv30U+v666+3WrRoYR07dqyK7za6ZWZmWo0bN7YWL15s7dy501q4cKFVv35965577gkew7NwbraLjRs36qZCmEmTJun3v/32W+PP+7XXXmt16dLFWrt2rbV69Wo9e8aQIUMcuuPqjSDzLJ555hkdzMTHx+spjdasWVN1T6aaUj80KmovvfRS8Bj1w+J3v/udVbduXf1L9he/+IUORFH1QSbPomq9/fbbVvv27fUfwG3atLGmT58e8nE1hcsDDzxgNWrUSB/Tp08fa8uWLVV8l9GvqKhIfx+o3w+JiYnWhRdeaP35z3+2SkpKgsfwLJyxYsWKCn9HqMDf9PP+/fff66CyVq1aVnJysjVs2DAdvMJ+PvU/u7OjAAAAqN7okwkAAADbEWQCAADAdgSZAAAAsB1BJgAAAGxHkAkAAADbEWQCAADAdgSZAAAAsB1BJgAAAGxHkAkAItK8eXOZPHkynwsAsAlBJgAAAGzHspIAqoVevXpJ+/bt9fuvvPKK1KhRQ+6880556KGHpHfv3rJy5cqQ41lxFwDODZlMANXGyy+/LHFxcbJu3TqZMmWKTJo0SV544QVZuHChNGnSRAece/bs0Q0AcG7izvH1AOAZ6enp8vTTT4vP55PWrVvL5s2b9fbw4cMlNjZWateuLampqW7fJgBEBTKZAKqNSy+9VAeYZTIyMmTr1q3i9/tdvS8AiEYEmQAAALAdQSaAamPt2rUh22vWrJGLLrpIl8rj4+PJaAKAjQgyAVQb+fn5kpWVJVu2bJHXXntNnnnmGRk1alRwnsxVq1bJrl27ZP/+/W7fKgB4HlMYAag2UxhdfPHFEggEZO7cuTp7qaYweuSRR3Q/TZXV/O1vf6sD0JKSEqYwAoBzRJAJoNoEmZ07d2ZVHwCoIpTLAQAAYDuCTAAAANiOcjkAAABsRyYTAAAAtiPIBAAAAEEmAAAAIh+ZTAAAANiOIBMAAAC2I8gEAACA7QgyAQAAYDuCTAAAANiOIBMAAABit/8PXnTvoc+mmrEAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "
"
       ]
@@ -774,7 +784,7 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
      "execution_count": 17,
@@ -783,7 +793,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "
"
       ]
@@ -793,14 +803,16 @@
     }
    ],
    "source": [
-    "ptvals = np.random.exponential(scale=10.0, size=10000) + np.random.exponential(scale=15.0, size=10000)\n",
+    "ptvals = np.random.exponential(scale=10.0, size=10000) + np.random.exponential(\n",
+    "    scale=15.0, size=10000\n",
+    ")\n",
     "etavals = np.random.normal(scale=1.1, size=10000)\n",
     "\n",
     "dists.fill(\n",
     "    dataset=\"gen2rwt\",\n",
     "    pt=ptvals,\n",
     "    eta=etavals,\n",
-    "    weight=gen2_to_gen1.to_evaluator().evaluate(ptvals, etavals)\n",
+    "    weight=gen2_to_gen1.to_evaluator().evaluate(ptvals, etavals),\n",
     ")\n",
     "\n",
     "fig, ax = plt.subplots()\n",
@@ -830,13 +842,13 @@
        "
📈 gen2_to_gen1_poly (v1)\n",
        "Fit to polynomial of order 2,2\n",
        "Fit status: The unconstrained solution is optimal.\n",
-       "chi2 = 5.079189048265459, P(dof=71) = 1.000\n",
+       "chi2 = 3.8810467430391604, P(dof=71) = 1.000\n",
        "Node counts: Formula: 1\n",
-       "╭──────────── â–ķ input ────────────â•Ū ╭──────────── â–ķ input ────────────â•Ū\n",
-       "│ pt (real)                       │ │ eta (real)                      │\n",
-       "│ No description                  │ │ No description                  │\n",
-       "│ Range: [-inf, inf), overflow ok │ │ Range: [-inf, inf), overflow ok │\n",
-       "╰─────────────────────────────────â•Ŋ ╰─────────────────────────────────â•Ŋ\n",
+       "╭───────── â–ķ input ──────────â•Ū ╭───────── â–ķ input ──────────â•Ū\n",
+       "│ pt (real)                  │ │ eta (real)                 │\n",
+       "│ No description             │ │ No description             │\n",
+       "│ Range: unused, overflow ok │ │ Range: unused, overflow ok │\n",
+       "╰────────────────────────────â•Ŋ ╰────────────────────────────â•Ŋ\n",
        "╭─── ◀ output ───â•Ū\n",
        "│ output (real)  │\n",
        "│ No description │\n",
@@ -847,13 +859,13 @@
        "📈 \u001b[1mgen2_to_gen1_poly\u001b[0m \u001b[1m(\u001b[0mv1\u001b[1m)\u001b[0m\n",
        "Fit to polynomial of order \u001b[1;36m2\u001b[0m,\u001b[1;36m2\u001b[0m\n",
        "Fit status: The unconstrained solution is optimal.\n",
-       "chi2 = \u001b[1;36m5.079189048265459\u001b[0m, \u001b[1;35mP\u001b[0m\u001b[1m(\u001b[0m\u001b[33mdof\u001b[0m=\u001b[1;36m71\u001b[0m\u001b[1m)\u001b[0m = \u001b[1;36m1.000\u001b[0m\n",
+       "chi2 = \u001b[1;36m3.8810467430391604\u001b[0m, \u001b[1;35mP\u001b[0m\u001b[1m(\u001b[0m\u001b[33mdof\u001b[0m=\u001b[1;36m71\u001b[0m\u001b[1m)\u001b[0m = \u001b[1;36m1.000\u001b[0m\n",
        "Node counts: \u001b[1mFormula\u001b[0m: \u001b[1;36m1\u001b[0m\n",
-       "╭──────────── â–ķ input ────────────â•Ū ╭──────────── â–ķ input ────────────â•Ū\n",
-       "│ \u001b[1mpt\u001b[0m (real)                       │ │ \u001b[1meta\u001b[0m (real)                      │\n",
-       "│ \u001b[3mNo description\u001b[0m                  │ │ \u001b[3mNo description\u001b[0m                  │\n",
-       "│ Range: [-inf, inf), overflow ok │ │ Range: [-inf, inf), overflow ok │\n",
-       "╰─────────────────────────────────â•Ŋ ╰─────────────────────────────────â•Ŋ\n",
+       "╭───────── â–ķ input ──────────â•Ū ╭───────── â–ķ input ──────────â•Ū\n",
+       "│ \u001b[1mpt\u001b[0m (real)                  │ │ \u001b[1meta\u001b[0m (real)                 │\n",
+       "│ \u001b[3mNo description\u001b[0m             │ │ \u001b[3mNo description\u001b[0m             │\n",
+       "│ Range: \u001b[1;31munused\u001b[0m, overflow ok │ │ Range: \u001b[1;31munused\u001b[0m, overflow ok │\n",
+       "╰────────────────────────────â•Ŋ ╰────────────────────────────â•Ŋ\n",
        "╭─── ◀ output ───â•Ū\n",
        "│ \u001b[1moutput\u001b[0m (real)  │\n",
        "│ \u001b[3mNo description\u001b[0m │\n",
@@ -870,7 +882,7 @@
     "gen2_to_gen1_poly, fit = correctionlib.convert.ndpolyfit(\n",
     "    points=[c.flatten() for c in centers],\n",
     "    values=sfhist.values().flatten(),\n",
-    "    weights=1/sfhist.variances().flatten(),\n",
+    "    weights=1 / sfhist.variances().flatten(),\n",
     "    varnames=[ax.name for ax in sfhist.axes],\n",
     "    degree=(2, 2),\n",
     ")\n",
@@ -895,7 +907,7 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
      "execution_count": 19,
@@ -904,7 +916,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "
"
       ]
@@ -918,7 +930,7 @@
     "    dataset=\"gen2rwt_poly\",\n",
     "    pt=ptvals,\n",
     "    eta=etavals,\n",
-    "    weight=gen2_to_gen1_poly.to_evaluator().evaluate(ptvals, etavals)\n",
+    "    weight=gen2_to_gen1_poly.to_evaluator().evaluate(ptvals, etavals),\n",
     ")\n",
     "\n",
     "\n",
@@ -945,8 +957,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "1.06 ms ¹ 15.6 Ξs per loop (mean ¹ std. dev. of 7 runs, 1,000 loops each)\n",
-      "2.81 ms ¹ 24 Ξs per loop (mean ¹ std. dev. of 7 runs, 100 loops each)\n"
+      "1.05 ms ¹ 14.4 Ξs per loop (mean ¹ std. dev. of 7 runs, 1,000 loops each)\n",
+      "2.81 ms ¹ 3.66 Ξs per loop (mean ¹ std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -976,8 +988,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "42.9 Ξs ¹ 324 ns per loop (mean ¹ std. dev. of 7 runs, 10,000 loops each)\n",
-      "15.2 Ξs ¹ 167 ns per loop (mean ¹ std. dev. of 7 runs, 100,000 loops each)\n"
+      "42.2 Ξs ¹ 168 ns per loop (mean ¹ std. dev. of 7 runs, 10,000 loops each)\n",
+      "14.9 Ξs ¹ 147 ns per loop (mean ¹ std. dev. of 7 runs, 100,000 loops each)\n"
      ]
     }
    ],
@@ -1011,14 +1023,16 @@
     "        cs.Variable(name=\"pt\", type=\"real\", description=\"Unsmeared jet pt\"),\n",
     "        cs.Variable(name=\"eta\", type=\"real\", description=\"Jet pseudorapdity\"),\n",
     "        cs.Variable(name=\"phi\", type=\"real\", description=\"Jet phi (entropy source)\"),\n",
-    "        cs.Variable(name=\"evt\", type=\"int\", description=\"Event number (entropy source)\"),\n",
+    "        cs.Variable(\n",
+    "            name=\"evt\", type=\"int\", description=\"Event number (entropy source)\"\n",
+    "        ),\n",
     "    ],\n",
     "    output=cs.Variable(name=\"rng\", type=\"real\"),\n",
     "    data=cs.HashPRNG(\n",
     "        nodetype=\"hashprng\",\n",
     "        inputs=[\"pt\", \"eta\", \"phi\", \"evt\"],\n",
     "        distribution=\"normal\",\n",
-    "    )\n",
+    "    ),\n",
     ")\n",
     "\n",
     "resmodel = cs.Correction(\n",
@@ -1035,7 +1049,7 @@
     "        edges=[10, 20, 30, 40, 50, 80, 120],\n",
     "        content=[0.3, 0.25, 0.20, 0.14, 0.06, 0.02],\n",
     "        flow=\"clamp\",\n",
-    "    )\n",
+    "    ),\n",
     ")"
    ]
   },
@@ -1057,7 +1071,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "
"
       ]
@@ -1072,10 +1086,9 @@
     "eventnumber = np.random.randint(123456, 123567, size=10000)\n",
     "\n",
     "# apply a pT-dependent smearing by scaling the standard normal draw\n",
-    "smear_val = (\n",
-    "    resrng.to_evaluator().evaluate(ptvals, etavals, phivals, eventnumber)\n",
-    "    * resmodel.to_evaluator().evaluate(ptvals)\n",
-    ")\n",
+    "smear_val = resrng.to_evaluator().evaluate(\n",
+    "    ptvals, etavals, phivals, eventnumber\n",
+    ") * resmodel.to_evaluator().evaluate(ptvals)\n",
     "pt_smeared = np.maximum(ptvals + smear_val, 0.0)\n",
     "\n",
     "\n",
@@ -1091,7 +1104,7 @@
    "source": [
     "## Chaining with CompoundCorrection\n",
     "\n",
-    "A CompoundCorrection allows to apply a sequence of corrections in order, refering to other corrections in the same CorrectionSet object. For example, we can merge the smearing and RNG into one:"
+    "A CompoundCorrection allows to apply a sequence of corrections in order, referring to other corrections in the same CorrectionSet object. For example, we can merge the smearing and RNG into one:"
    ]
   },
   {
@@ -1122,25 +1135,33 @@
     "            inputs=[\n",
     "                cs.Variable(name=\"pt\", type=\"real\", description=\"Unsmeared jet pt\"),\n",
     "                cs.Variable(name=\"eta\", type=\"real\", description=\"Jet pseudorapdity\"),\n",
-    "                cs.Variable(name=\"phi\", type=\"real\", description=\"Jet phi (entropy source)\"),\n",
-    "                cs.Variable(name=\"evt\", type=\"int\", description=\"Event number (entropy source)\"),\n",
+    "                cs.Variable(\n",
+    "                    name=\"phi\", type=\"real\", description=\"Jet phi (entropy source)\"\n",
+    "                ),\n",
+    "                cs.Variable(\n",
+    "                    name=\"evt\", type=\"int\", description=\"Event number (entropy source)\"\n",
+    "                ),\n",
     "            ],\n",
-    "            output=cs.Variable(name=\"shift\", type=\"real\", description=\"Additive shift to jet pT\"),\n",
+    "            output=cs.Variable(\n",
+    "                name=\"shift\", type=\"real\", description=\"Additive shift to jet pT\"\n",
+    "            ),\n",
     "            inputs_update=[],\n",
     "            input_op=\"*\",\n",
     "            output_op=\"*\",\n",
     "            stack=[\"resmodel\", \"resrng\"],\n",
     "        )\n",
-    "    ]\n",
+    "    ],\n",
     ")\n",
     "\n",
     "oneshot = cset.to_evaluator().compound[\"resolution_model\"]\n",
     "\n",
     "print(\"One-shot smearing is equivalent to two-step procedure?\")\n",
-    "print(np.allclose(\n",
-    "    oneshot.evaluate(ptvals, etavals, phivals, eventnumber),\n",
-    "    smear_val,\n",
-    "))"
+    "print(\n",
+    "    np.allclose(\n",
+    "        oneshot.evaluate(ptvals, etavals, phivals, eventnumber),\n",
+    "        smear_val,\n",
+    "    )\n",
+    ")"
    ]
   },
   {
@@ -1158,7 +1179,7 @@
    "source": [
     "## Systematics\n",
     "\n",
-    "There are many ways to encode systematic uncertainties within correctionlib, although no nodes are dedicated to the task. See [issue #4](https://github.com/cms-nanoAOD/correctionlib/issues/4) to discuss further the idea of having a dedicated systematic node. The most straightforward option is to use a Category node with string lookup to switch the behavior depending on the active systematic. Below we modify our `ptweight` from before to produce a systematically larger event weight when the `MuonEffUp` systematic is specified, while producing the nominal event weight for any other string key, by taking advantage of the `default=` keywoard in the Category node. We also use the `flow=` keyword in the shifted binning to increase the systematic uncertainty for data with muon $p_T$ larger than 120."
+    "There are many ways to encode systematic uncertainties within correctionlib, although no nodes are dedicated to the task. See [issue #4](https://github.com/cms-nanoAOD/correctionlib/issues/4) to discuss further the idea of having a dedicated systematic node. The most straightforward option is to use a Category node with string lookup to switch the behavior depending on the active systematic. Below we modify our `ptweight` from before to produce a systematically larger event weight when the `MuonEffUp` systematic is specified, while producing the nominal event weight for any other string key, by taking advantage of the `default=` keyword in the Category node. We also use the `flow=` keyword in the shifted binning to increase the systematic uncertainty for data with muon $p_T$ larger than 120."
    ]
   },
   {
@@ -1211,9 +1232,11 @@
     "    version=1,\n",
     "    inputs=[\n",
     "        cs.Variable(name=\"pt\", type=\"real\", description=\"Muon transverse momentum\"),\n",
-    "        cs.Variable(name=\"syst\", type=\"string\", description=\"Systematic\")\n",
+    "        cs.Variable(name=\"syst\", type=\"string\", description=\"Systematic\"),\n",
     "    ],\n",
-    "    output=cs.Variable(name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"),\n",
+    "    output=cs.Variable(\n",
+    "        name=\"weight\", type=\"real\", description=\"Multiplicative event weight\"\n",
+    "    ),\n",
     "    data=cs.Category(\n",
     "        nodetype=\"category\",\n",
     "        input=\"syst\",\n",
@@ -1260,7 +1283,7 @@
     }
    ],
    "source": [
-    "ptweight.to_evaluator().evaluate(135., \"nominal\")"
+    "ptweight.to_evaluator().evaluate(135.0, \"nominal\")"
    ]
   },
   {
@@ -1278,6 +1301,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import gzip\n",
+    "\n",
     "cset = cs.CorrectionSet(\n",
     "    schema_version=2,\n",
     "    description=\"my custom corrections\",\n",
@@ -1290,8 +1315,7 @@
     "\n",
     "with open(\"mycorrections.json\", \"w\") as fout:\n",
     "    fout.write(cset.model_dump_json(exclude_unset=True))\n",
-    "    \n",
-    "import gzip\n",
+    "\n",
     "\n",
     "with gzip.open(\"mycorrections.json.gz\", \"wt\") as fout:\n",
     "    fout.write(cset.model_dump_json(exclude_unset=True))"
@@ -1325,7 +1349,7 @@
       "positional arguments:\n",
       "  {validate,summary,merge,config}\n",
       "    validate            Check if all files are valid\n",
-      "    summary             Print a summmary of the corrections\n",
+      "    summary             Print a summary of the corrections\n",
       "    merge               Merge one or more correction files and print to stdout\n",
       "    config              Configuration and linking information\n",
       "\n",
@@ -1379,7 +1403,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Overwriting main.cc\n"
+      "Writing main.cc\n"
      ]
     }
    ],
diff --git a/data/conversion.py b/data/conversion.py
index f9b0d471..cf43618c 100755
--- a/data/conversion.py
+++ b/data/conversion.py
@@ -133,7 +133,7 @@ def build_systs(sf):
             {
                 "name": "flavor",
                 "type": "int",
-                "description": "BTV flavor definiton: 0=b, 1=c, 2=udsg",
+                "description": "BTV flavor definition: 0=b, 1=c, 2=udsg",
             },
             {"name": "abseta", "type": "real"},
             {"name": "pt", "type": "real"},
diff --git a/docs/conf.py b/docs/conf.py
index b9399839..edbdfacf 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -7,7 +7,6 @@
 # Warning: do not change the path here. To use autodoc, you need to install the
 # package first.
 
-from typing import List
 
 # -- Project information -----------------------------------------------------
 
diff --git a/docs/index.md b/docs/index.md
index 3b46ba2d..647bc87c 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,59 +1,64 @@
 # correctionlib
 
-The purpose of this library is to provide a well-structured JSON data format for a
-wide variety of ad-hoc correction factors encountered in a typical HEP analysis and
-a companion evaluation tool suitable for use in C++ and python programs.
-Here we restrict our definition of correction factors to a class of functions with
-scalar inputs that produce a scalar output.
-
+The purpose of this library is to provide a well-structured JSON data format for
+a wide variety of ad-hoc correction factors encountered in a typical HEP
+analysis and a companion evaluation tool suitable for use in C++ and python
+programs. Here we restrict our definition of correction factors to a class of
+functions with scalar inputs that produce a scalar output.
 
 In python, the function signature is:
 
 ```python
 from typing import Union
 
-def f(*args: Union[str,int,float]) -> float:
+
+def f(*args: Union[str, int, float]) -> float:
     return ...
 ```
 
 In C++, the evaluator implements this currently as:
+
 ```cpp
 double Correction::evaluate(const std::vector>& values) const;
 ```
 
 The supported function classes include:
 
-  * multi-dimensional binned lookups;
-  * binned lookups pointing to multi-argument formulas with a restricted
-    math function set (`exp`, `sqrt`, etc.);
-  * categorical (string or integer enumeration) maps;
-  * input transforms (updating one input value in place); and
-  * compositions of the above.
+- multi-dimensional binned lookups;
+- binned lookups pointing to multi-argument formulas with a restricted math
+  function set (`exp`, `sqrt`, etc.);
+- categorical (string or integer enumeration) maps;
+- input transforms (updating one input value in place); and
+- compositions of the above.
 
-Each function type is represented by a "node" in a call graph and holds all
-of its parameters in a JSON structure, described by the JSON schema.
-Possible future extension nodes might include weigted sums (which, when composed with
-the others, could represent a BDT) and perhaps simple MLPs.
+Each function type is represented by a "node" in a call graph and holds all of
+its parameters in a JSON structure, described by the JSON schema. Possible
+future extension nodes might include weigted sums (which, when composed with the
+others, could represent a BDT) and perhaps simple MLPs.
 
 The tool should provide:
 
-  * standardized, versioned [JSON schemas](https://json-schema.org/);
-  * forward-porting tools (to migrate data written in older schema versions); and
-  * a well-optimized C++ evaluator and python bindings (with numpy vectorization support).
+- standardized, versioned [JSON schemas](https://json-schema.org/);
+- forward-porting tools (to migrate data written in older schema versions); and
+- a well-optimized C++ evaluator and python bindings (with numpy vectorization
+  support).
 
 This tool will definitely not provide:
 
-  * support for `TLorentzVector` or other object-type inputs (such tools should be written
-    as a higher-level tool depending on this library as a low-level tool)
-
-Formula support currently includes a mostly-complete subset of the ROOT library `TFormula` class,
-and is implemented in a threadsafe standalone manner. The parsing grammar is formally defined
-and parsed through the use of a header-only [PEG parser library](https://github.com/yhirose/cpp-peglib).
-The supported features mirror CMSSW's [reco::formulaEvaluator](https://github.com/cms-sw/cmssw/pull/11516)
-and fully passes the test suite for that utility with the purposeful exception of the `TMath::` namespace.
-The python bindings may be able to call into [numexpr](https://numexpr.readthedocs.io/en/latest/user_guide.html),
-though, due to the tree-like structure of the corrections, it may prove difficult to exploit vectorization
-at levels other than the entrypoint.
+- support for `TLorentzVector` or other object-type inputs (such tools should be
+  written as a higher-level tool depending on this library as a low-level tool)
+
+Formula support currently includes a mostly-complete subset of the ROOT library
+`TFormula` class, and is implemented in a threadsafe standalone manner. The
+parsing grammar is formally defined and parsed through the use of a header-only
+[PEG parser library](https://github.com/yhirose/cpp-peglib). The supported
+features mirror CMSSW's
+[reco::formulaEvaluator](https://github.com/cms-sw/cmssw/pull/11516) and fully
+passes the test suite for that utility with the purposeful exception of the
+`TMath::` namespace. The python bindings may be able to call into
+[numexpr](https://numexpr.readthedocs.io/en/latest/user_guide.html), though, due
+to the tree-like structure of the corrections, it may prove difficult to exploit
+vectorization at levels other than the entrypoint.
 
 ```{toctree}
 ---
@@ -71,9 +76,8 @@ convert
 core
 ```
 
-
 ## Indices and tables
 
-* {ref}`genindex`
-* {ref}`modindex`
-* {ref}`search`
+- {ref}`genindex`
+- {ref}`modindex`
+- {ref}`search`
diff --git a/docs/install.md b/docs/install.md
index 11130e20..d544c28f 100644
--- a/docs/install.md
+++ b/docs/install.md
@@ -1,58 +1,67 @@
 # Installation
 
-This package provides both a C++ evaluator with python bindings and
-a set of python tools to convert, validate, and inspect files with corrections
-It is installed as a python package (see e.g.
-[this tutorial](https://packaging.python.org/tutorials/installing-packages/)
-for an introduction), using [scikit-build](https://scikit-build.readthedocs.io/)
-and thus [CMake](https://cmake.org/), for the C++ components.
-Builds have been tested in Windows, OS X, and Linux, and the python bindings
-can be compiled against both python2 (with limited functionality) and python3,
-as well as from within a CMSSW environment.
-Note that CMSSW ``11_2_X`` and above has ROOT accessible from python 3.
+This package provides both a C++ evaluator with python bindings and a set of
+python tools to convert, validate, and inspect files with corrections It is
+installed as a python package (see e.g.
+[this tutorial](https://packaging.python.org/tutorials/installing-packages/) for
+an introduction), using [scikit-build](https://scikit-build.readthedocs.io/) and
+thus [CMake](https://cmake.org/), for the C++ components. Builds have been
+tested in Windows, OS X, and Linux, and the python bindings can be compiled
+against both python2 (with limited functionality) and python3, as well as from
+within a CMSSW environment. Note that CMSSW `11_2_X` and above has ROOT
+accessible from python 3.
 
 ## Inside CMSSW
 
-For CMSSW releases from the `11_3_X` branch on, correctionlib is included
-as the `py3-correctionlib` tool, and from the `12_1_X` branch version 2.0,
-which has the schema version 2.0 that is used by most of the corrections.
-If the tool included in CMSSW supports the version you want to use,
-no additional installation is needed.
-The package version can also be found with the command-line tool:
+For CMSSW releases from the `11_3_X` branch on, correctionlib is included as the
+`py3-correctionlib` tool, and from the `12_1_X` branch version 2.0, which has
+the schema version 2.0 that is used by most of the corrections. If the tool
+included in CMSSW supports the version you want to use, no additional
+installation is needed. The package version can also be found with the
+command-line tool:
+
 ```bash
 correction config --version
 ```
 
-In CMSSW `10_6_30`, there is a dedicated backport of correctionlib, however
-it is only the python 2 version and hence only provides the `correctionlib._core`
+In CMSSW `10_6_30`, there is a dedicated backport of correctionlib, however it
+is only the python 2 version and hence only provides the `correctionlib._core`
 bindings.
 
 For older release cycles the package can be installed in the user area with
+
 ```bash
 python3 -m pip install --user --no-binary=correctionlib correctionlib
 ```
-for python3.
-Alternatively, [this script](https://gist.github.com/pieterdavid/8f43f302e9f8a71f92702101600b7ddb),
-can be used to install a `py3-correctionlib` tool similar to the one provided in more recent releases,
-or a `py2-correctionlib` tool with limited functionality.
+
+for python3. Alternatively,
+[this script](https://gist.github.com/pieterdavid/8f43f302e9f8a71f92702101600b7ddb),
+can be used to install a `py3-correctionlib` tool similar to the one provided in
+more recent releases, or a `py2-correctionlib` tool with limited functionality.
 
 The package can be built as follows:
+
 ```bash
 git clone --recursive git@github.com:cms-nanoAOD/correctionlib.git
 cd correctionlib
 make PYTHON=python
 make install  # set PREFIX=... to change from default (./correctionlib)
 ```
+
 where `python` is the name of the python scram tool you intend to link against.
-This will output a `correctionlib` directory that acts as a python package, and can be moved where needed.
+This will output a `correctionlib` directory that acts as a python package, and
+can be moved where needed.
 
 ## Outside CMSSW
 
 To install in an environment that has python 3, you can simply
+
 ```bash
 python3 -m pip install correctionlib
 ```
+
 (possibly with `--user`, or in a virtualenv, etc.)
+
 ```{admonition} Wheels or installing from source?
 The above command will try to use python wheels, prebuilt binary packages,
 since it is faster and more efficient.
@@ -64,41 +73,47 @@ which will start from the source package and build the C++ components in your en
 ```
 
 If you wish to install the latest development version, this should work:
+
 ```bash
 python3 -m pip install git+https://github.com/cms-nanoAOD/correctionlib.git
 ```
 
 ## With python 2 (outside CMSSW)
 
-To compile with python2 support, consider using python 3 :).
-If you considered that and still want to use python2, the following recipe may work
-to install only the `correctionlib._core` evaluator,
-which allows to use the C++ evaluator from python2 and python3
-(the schema tools and high-level bindings are python3-only):
+To compile with python2 support, consider using python 3 :). If you considered
+that and still want to use python2, the following recipe may work to install
+only the `correctionlib._core` evaluator, which allows to use the C++ evaluator
+from python2 and python3 (the schema tools and high-level bindings are
+python3-only):
+
 ```bash
 git clone --recursive git@github.com:cms-nanoAOD/correctionlib.git
 cd correctionlib
 make PYTHON=python2
 make install  # set PREFIX=... to change from default (./correctionlib)
 ```
-This will output a `correctionlib` directory that acts as a python package, and can be moved where needed.
+
+This will output a `correctionlib` directory that acts as a python package, and
+can be moved where needed.
 
 ## Usage from python and C++
 
-After the installation following one of the recipes above,
-the correctionlib python package should be available,
-as well as the `correction` command-line utility.
-In case the latter is not on your path for some reason, it can also be invoked via
-`python3 -m correctionlib.cli`.
+After the installation following one of the recipes above, the correctionlib
+python package should be available, as well as the `correction` command-line
+utility. In case the latter is not on your path for some reason, it can also be
+invoked via `python3 -m correctionlib.cli`.
+
+The C++ evaluator library is distributed as part of the python package, and it
+can be linked to directly without using python. If you are using CMake you can
+depend on it by including the output of `correction config --cmake` in your
+cmake invocation. A complete cmake example that builds a user C++ application
+against correctionlib and ROOT RDataFrame can be
+[found here](https://gist.github.com/pieterdavid/a560e65658386d70a1720cb5afe4d3e9).
 
-The C++ evaluator library is distributed as part of the python package, and it can be
-linked to directly without using python. If you are using CMake you can depend on it by including
-the output of `correction config --cmake` in your cmake invocation. A complete cmake
-example that builds a user C++ application against correctionlib and ROOT RDataFrame
-can be [found here](https://gist.github.com/pieterdavid/a560e65658386d70a1720cb5afe4d3e9).
+For manual compilation, include and linking definitions can similarly be found
+via `correction config --cflags --ldflags`. For example, the demo application
+can be compiled with:
 
-For manual compilation, include and linking definitions can similarly be found via `correction config --cflags --ldflags`.
-For example, the demo application can be compiled with:
 ```bash
 wget https://raw.githubusercontent.com/cms-nanoAOD/correctionlib/master/src/demo.cc
 g++ $(correction config --cflags --ldflags --rpath) demo.cc -o demo
diff --git a/pyproject.toml b/pyproject.toml
index 328106d1..8424c931 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,7 +57,7 @@ test = [
   "uproot >=4.0.4",
   "requests",
   "scipy",
-  "pytest >=4.6",
+  "pytest >=6.0",
   "awkward >=2.2.2",
   "dask-awkward >=2024.1.1",
 ]
@@ -80,9 +80,29 @@ dev = [
   {include-group = "docs"},
   "pre-commit",
   "mypy",
+  "ruff",
   "uhi",
 ]
 
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = ["-ra"]
+testpaths = ["tests"]
+
+[tool.check-manifest]
+ignore = [
+  ".github/**",
+  "docs/**",
+  ".pre-commit-config.yaml",
+  ".readthedocs.yml",
+  "src/*/version.py",
+  "data/**",
+  "Makefile",
+  "cpp-peglib/**",
+  "pybind11/**",
+  "rapidjson/**",
+]
+
 [tool.mypy]
 python_version = "3.9"
 files = ["src"]
@@ -95,6 +115,16 @@ follow_untyped_imports = true
 module = ["cppyy.*", "scipy.*"]
 ignore_missing_imports = true
 
+[tool.ruff.lint]
+select = [
+  "E",  # all errors
+  "F",  # all pyflakes checks
+  "I",  # import-related checks
+]
+ignore = [
+  "E501", # line too long (comments and docstrings, code will be formatted with ruff)
+]
+
 [project.scripts]
 correction = "correctionlib.cli:main"
 
@@ -121,3 +151,6 @@ test-skip = ["*-musllinux_*", "cp3{10,11,12}-win32"]
 [tool.cibuildwheel.environment]
 # this makes sure that we build only on platforms that have a corresponding numpy wheel
 PIP_ONLY_BINARY = ":all:"
+
+[tool.codespell]
+ignore-regex = "[A-Za-z0-9+/]{100,}"  # ignore long base64 strings
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 830b4e6d..00000000
--- a/setup.cfg
+++ /dev/null
@@ -1,44 +0,0 @@
-[tool:pytest]
-addopts = -rs -s -Wd
-testpaths =
-    tests
-
-[check-manifest]
-ignore =
-  .github/**
-  docs/**
-  .pre-commit-config.yaml
-  .readthedocs.yml
-  src/*/version.py
-  data/**
-  Makefile
-  cpp-peglib/**
-  pybind11/**
-  rapidjson/**
-
-[flake8]
-ignore = E203, E231, E501, E722, W503, B902, B905, B950
-select = C,E,F,W,T,B,B9,I
-per-file-ignores =
-    tests/*: T
-
-[isort]
-multi_line_output = 3
-include_trailing_comma = True
-force_grid_wrap = 0
-use_parentheses = True
-ensure_newline_before_comments = True
-line_length = 88
-
-[mypy]
-files = src
-python_version = 3.9
-
-[mypy-numpy]
-ignore_missing_imports = True
-
-[mypy-uproot]
-ignore_missing_imports = True
-
-[mypy-scipy.*]
-ignore_missing_imports = True
diff --git a/src/correctionlib/JSONEncoder.py b/src/correctionlib/JSONEncoder.py
index d64ab279..41eb3809 100755
--- a/src/correctionlib/JSONEncoder.py
+++ b/src/correctionlib/JSONEncoder.py
@@ -113,7 +113,7 @@ def encode(self, obj: Any) -> str:
                 if not retval:
                     lines = (",\n" + indent_str).join(output)  # lines between brackets
                     if (
-                        grandparent == dict or self.breakbrackets
+                        grandparent is dict or self.breakbrackets
                     ):  # break first line after opening bracket
                         retval = (
                             "[\n" + indent_str + lines + "\n" + " " * self._indent + "]"
diff --git a/src/correctionlib/cli.py b/src/correctionlib/cli.py
index 08aec9b3..ae3c26f7 100644
--- a/src/correctionlib/cli.py
+++ b/src/correctionlib/cli.py
@@ -87,9 +87,7 @@ def summary(console: Console, args: argparse.Namespace) -> int:
 
 
 def setup_summary(subparsers):
-    parser = subparsers.add_parser(
-        "summary", help="Print a summmary of the corrections"
-    )
+    parser = subparsers.add_parser("summary", help="Print a summary of the corrections")
     parser.set_defaults(command=summary)
     parser.add_argument(
         "--ignore-float-inf",
diff --git a/src/correctionlib/schemav2.py b/src/correctionlib/schemav2.py
index 0b9c208d..039f22bc 100644
--- a/src/correctionlib/schemav2.py
+++ b/src/correctionlib/schemav2.py
@@ -287,7 +287,7 @@ def validate_content(cls, content: list[CategoryItem]) -> list[CategoryItem]:
             keytype = type(content[0].key)
             if not all(isinstance(item.key, keytype) for item in content):
                 raise ValueError(
-                    f"Keys in the Category node do not have a homogenous type, expected all {keytype}"
+                    f"Keys in the Category node do not have a homogeneous type, expected all {keytype}"
                 )
 
             keys = {item.key for item in content}
diff --git a/tests/test_core.py b/tests/test_core.py
index 2ef8aafd..b62a4c5f 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -387,9 +387,7 @@ def evaluate(expr, variables, parameters):
                     )
                 )
             )
-        ) + (
-            (x < v[6]) * v[7]
-        )
+        ) + ((x < v[6]) * v[7])
         assert evaluate(
             "(max(0.,1.03091-0.051154*pow(x,-0.154227))-max(0.,1.03091-0.051154*pow(208.,-0.154227)))+[7]*((-2.36997+0.413917*log(x))/x-(-2.36997+0.413917*log(208))/208)",
             [x],
@@ -397,9 +395,7 @@ def evaluate(expr, variables, parameters):
         ) == (
             max(0.0, 1.03091 - 0.051154 * math.pow(x, -0.154227))
             - max(0.0, 1.03091 - 0.051154 * math.pow(208.0, -0.154227))
-        ) + v[
-            7
-        ] * (
+        ) + v[7] * (
             (-2.36997 + 0.413917 * math.log(x)) / x
             - (-2.36997 + 0.413917 * math.log(208)) / 208
         )
@@ -620,9 +616,7 @@ def evaluate(expr, variables, parameters):
             + v[3] * (x - 225)
             + v[4] * ((x - 225) * (x - 225))
             + v[5] * ((x - 225) * (x - 225) * (x - 225))
-        ) * (
-            x > 225
-        )
+        ) * (x > 225)
 
     with pytest.raises(RuntimeError):
         evaluate("doesNotExist(2)", [], [])
diff --git a/tests/test_jsonencoder.py b/tests/test_jsonencoder.py
index 8fd1087a..7f90ee0b 100755
--- a/tests/test_jsonencoder.py
+++ b/tests/test_jsonencoder.py
@@ -246,9 +246,9 @@ def test_jsonencode():
     }
   }
 }"""
-    assert (
-        formatted == expected
-    ), f"Formatted does not match expected:\nExpected: {expected}\nFormatted: {formatted}"
-    assert (
-        retrieved == data
-    ), f"Data before and after encoding do not match:\nBefore: {data}\nFormatted: {formatted}"
+    assert formatted == expected, (
+        f"Formatted does not match expected:\nExpected: {expected}\nFormatted: {formatted}"
+    )
+    assert retrieved == data, (
+        f"Data before and after encoding do not match:\nBefore: {data}\nFormatted: {formatted}"
+    )