diff --git a/.copier-answers.yml b/.copier-answers.yml new file mode 100644 index 0000000..6c4f076 --- /dev/null +++ b/.copier-answers.yml @@ -0,0 +1,15 @@ +# Changes here will be overwritten by Copier +_commit: v1.3.0 +_src_path: gh:lincc-frameworks/python-project-template +author_email: annlee@andrew.cmu.edu +author_name: Ann Lee +create_example_module: false +custom_install: true +include_notebooks: true +module_name: flexcode +mypy_type_checking: none +preferred_linter: black +project_license: none +project_name: flexcode +use_gitlfs: none +use_isort: true diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml new file mode 100644 index 0000000..e6775cd --- /dev/null +++ b/.github/workflows/linting.yml @@ -0,0 +1,33 @@ +# This workflow will install Python dependencies, then perform static linting analysis. +# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions + +name: Lint + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Set up Python 3.10 + uses: actions/setup-python@v4 + with: + python-version: '3.10' + - name: Install dependencies + run: | + sudo apt-get update + python -m pip install --upgrade pip + pip install . + pip install .[dev] + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Analyze code with linter + + uses: psf/black@stable + with: + src: ./src + diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml new file mode 100644 index 0000000..cfd43b6 --- /dev/null +++ b/.github/workflows/publish-to-pypi.yml @@ -0,0 +1,39 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +name: Upload Python Package + +on: + release: + types: [published] + +permissions: + contents: read + +jobs: + deploy: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build + - name: Publish package + uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} \ No newline at end of file diff --git a/.github/workflows/smoke-test.yml b/.github/workflows/smoke-test.yml new file mode 100644 index 0000000..e319191 --- /dev/null +++ b/.github/workflows/smoke-test.yml @@ -0,0 +1,33 @@ +# This workflow will run daily at 06:45. +# It will install Python dependencies and run tests with a variety of Python versions. + +name: Unit test smoke test + +on: + schedule: + - cron: 45 6 * * * + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ['3.8', '3.9', '3.10'] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + sudo apt-get update + python -m pip install --upgrade pip + pip install . + pip install .[dev] + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Run unit tests with pytest + run: | + python -m pytest tests diff --git a/.github/workflows/testing-and-coverage.yml b/.github/workflows/testing-and-coverage.yml new file mode 100644 index 0000000..e2f8f92 --- /dev/null +++ b/.github/workflows/testing-and-coverage.yml @@ -0,0 +1,43 @@ +# This workflow will install Python dependencies, run tests and report code coverage with a variety of Python versions +# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions + +name: Unit test and code coverage + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ['3.8', '3.9', '3.10'] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + sudo apt-get update + python -m pip install --upgrade pip + pip install . + pip install .[dev] + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Run unit tests with pytest + run: | + python -m pytest tests --cov=flexcode --cov-report=xml + - name: Upload coverage report to codecov + uses: codecov/codecov-action@v3 + - name: Install notebook requirements + run: | + sudo apt-get install pandoc + - name: Build docs + run: | + sphinx-build -T -E -b html -d docs/build/doctrees ./docs docs/build/html \ No newline at end of file diff --git a/.gitignore b/.gitignore index 90cacf2..523b316 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,140 @@ -tests/__pycache__/* -.idea/* -build/* -dist/* -src/flexcode.egg-info/* +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ .eggs/ -vignettes/.ipynb_checkpoints/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST +_version.py + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ +_readthedocs/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# vscode +.vscode/ + +# dask +dask-worker-space/ + +# tmp directory +tmp/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..42562ff --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,99 @@ +repos: + + # Clear output from jupyter notebooks so that only the input cells are committed. + - repo: local + hooks: + - id: jupyter-nb-clear-output + name: jupyter-nb-clear-output + description: Clear output from Jupyter notebooks. + files: \.ipynb$ + stages: [commit] + language: system + entry: jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace + + # Run unit tests, verify that they pass. Note that coverage is run against + # the ./src directory here because that is what will be committed. In the + # github workflow script, the coverage is run against the installed package + # and uploaded to Codecov by calling pytest like so: + # `python -m pytest --cov= --cov-report=xml` + - repo: local + hooks: + - id: pytest-check + name: pytest-check + description: Run unit tests with pytest. + entry: bash -c "if python -m pytest --co -qq; then python -m pytest --cov=./src --cov-report=html; fi" + language: system + pass_filenames: false + always_run: true + + # prevents committing directly branches named 'main' and 'master'. + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: no-commit-to-branch + name: Don't commit to main or master branch + description: Prevent the user from committing directly to the primary branch. + - id: check-added-large-files + name: Check for large files + description: Prevent the user from committing very large files. + args: ['--maxkb=500'] + + # verify that pyproject.toml is well formed + - repo: https://github.com/abravalheri/validate-pyproject + rev: v0.12.1 + hooks: + - id: validate-pyproject + name: Validate syntax of pyproject.toml + description: Verify that pyproject.toml adheres to the established schema. + + # Automatically sort the imports used in .py files + - repo: https://github.com/pycqa/isort + rev: 5.12.0 + hooks: + - id: isort + name: isort (python files in src/ and tests/) + description: Sort and organize imports in .py files. + types: [python] + files: ^(src|tests)/ + + + # Analyze the code style and report code that doesn't adhere. + - repo: https://github.com/psf/black + rev: 23.1.0 + hooks: + - id: black + types: [python] + files: ^(src|tests)/ + # It is recommended to specify the latest version of Python + # supported by your project here, or alternatively use + # pre-commit's default_language_version, see + # https://pre-commit.com/#top_level-default_language_version + language_version: python3.10 + + + # Make sure Sphinx can build the documentation while explicitly omitting + # notebooks from the docs, so users don't have to wait through the execution + # of each notebook or each commit. By default, these will be checked in the + # GitHub workflows. + - repo: local + hooks: + - id: sphinx-build + name: Build documentation with Sphinx + entry: sphinx-build + language: system + always_run: true + exclude_types: [file, symlink] + args: + [ + "-M", # Run sphinx in make mode, so we can use -D flag later + # Note: -M requires next 3 args to be builder, source, output + "html", # Specify builder + "./docs", # Source directory of documents + "./docs/build/html", # Output directory for rendered documents + "-T", # Show full trace back on exception + "-E", # Don't use saved env; always read all files + "-d", # Flag for cached environment and doctrees + "./docs/build/doctrees", # Directory + "-D", # Flag to override settings in conf.py + "exclude_patterns=notebooks/*", # Exclude our notebooks from pre-commit + ] \ No newline at end of file diff --git a/.readthedocs.yml b/.readthedocs.yml new file mode 100644 index 0000000..817d2b0 --- /dev/null +++ b/.readthedocs.yml @@ -0,0 +1,22 @@ +# .readthedocs.yml +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +build: + os: ubuntu-22.04 + tools: + python: "3.10" + +# Build documentation in the docs/ directory with Sphinx +sphinx: + configuration: docs/conf.py + +# Optionally declare the Python requirements required to build your docs +python: + install: + - requirements: docs/requirements.txt + - method: pip + path: . \ No newline at end of file diff --git a/archive/README.md b/archive/README.md new file mode 100644 index 0000000..c7c23ac --- /dev/null +++ b/archive/README.md @@ -0,0 +1,10 @@ +This directory contains **archived** configuration files. + +Flexcode has been migrated to use the [LINCC Frameworks Python Project Template](https://github.com/lincc-frameworks/python-project-template) which uses a pyproject.toml file for build definitions and requirements. + +The pyproject.toml file replaces the need for setup.py, setup.cfg, and ton.ini, +but the files will be retained for a period of time as a convenience. + +**These files will be removed at a later date!** +Please do not use them. +Update pyproject.toml in the base directory if changes to the build are required. diff --git a/setup.cfg b/archive/x_setup.cfg similarity index 100% rename from setup.cfg rename to archive/x_setup.cfg diff --git a/setup.py b/archive/x_setup.py similarity index 100% rename from setup.py rename to archive/x_setup.py diff --git a/tox.ini b/archive/x_tox.ini similarity index 100% rename from tox.ini rename to archive/x_tox.ini diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..2f440e4 --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,31 @@ +# Makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= -T -E -d _build/doctrees -D language=en +EXCLUDENB ?= -D exclude_patterns="notebooks/*" +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = ../_readthedocs/ + +.PHONY: help no-nb no-notebooks clean Makefile + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +# Build all Sphinx docs locally, except the notebooks +no-nb no-notebooks: + @$(SPHINXBUILD) -M html "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(EXCLUDENB) $(O) + +# Cleans up files generated by the build process +clean: + rm -r "_build/doctrees" + rm -r "$(BUILDDIR)" + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..73b6563 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,46 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + + +import os +import sys + +import autoapi +from importlib.metadata import version + +# Define path to the code to be documented **relative to where conf.py (this file) is kept** +sys.path.insert(0, os.path.abspath('../src/')) + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = "flexcode" +copyright = "2023, Ann Lee" +author = "Ann Lee" +release = version("flexcode") +# for example take major/minor +version = ".".join(release.split(".")[:2]) + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = ["sphinx.ext.mathjax", "sphinx.ext.napoleon", "sphinx.ext.viewcode"] + +extensions.append("autoapi.extension") +extensions.append("nbsphinx") + +templates_path = [] +exclude_patterns = ['_build', '**.ipynb_checkpoints'] + +master_doc = "index" # This assumes that sphinx-build is called from the root directory +html_show_sourcelink = False # Remove 'view source code' from top of page (for html, not python) +add_module_names = False # Remove namespaces from class/method signatures + +autoapi_type = "python" +autoapi_dirs = ["../src"] +autoapi_add_toc_tree_entry = False +autoapi_member_order = "bysource" + +html_theme = "sphinx_rtd_theme" diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..faaefad --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,13 @@ +.. flexcode documentation main file. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to flexcode's documentation! +======================================================================================== + +.. toctree:: + :hidden: + + Home page + API Reference + Notebooks diff --git a/docs/notebooks.rst b/docs/notebooks.rst new file mode 100644 index 0000000..bc4181b --- /dev/null +++ b/docs/notebooks.rst @@ -0,0 +1,6 @@ +Notebooks +======================================================================================== + +.. toctree:: + + Introducing Jupyter Notebooks \ No newline at end of file diff --git a/docs/notebooks/README.md b/docs/notebooks/README.md new file mode 100644 index 0000000..4eb938c --- /dev/null +++ b/docs/notebooks/README.md @@ -0,0 +1 @@ +Put your Jupyter notebooks here :) \ No newline at end of file diff --git a/docs/notebooks/intro_notebook.ipynb b/docs/notebooks/intro_notebook.ipynb new file mode 100644 index 0000000..2e7779f --- /dev/null +++ b/docs/notebooks/intro_notebook.ipynb @@ -0,0 +1,111 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "accepting-editor", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Introducing Jupyter Notebooks\n", + "\n", + "_(The example used here is JamesALeedham's notebook: [intro.ipynb](https://github.com/JamesALeedham/Sphinx-Autosummary-Recursion/blob/master/docs/notebooks/intro.ipynb))_\n", + "\n", + "First, set up the environment:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "actual-thirty", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib\n", + "import matplotlib.pyplot as pl\n", + "import numpy as np\n", + "\n", + "try:\n", + " from IPython import get_ipython\n", + " get_ipython().run_line_magic('matplotlib', 'inline')\n", + "except AttributeError:\n", + " print('Magic function can only be used in IPython environment')\n", + " matplotlib.use('Agg')\n", + "\n", + "pl.rcParams[\"figure.figsize\"] = [15, 8]" + ] + }, + { + "cell_type": "markdown", + "id": "coral-upper", + "metadata": { + "cell_marker": "\"\"\"", + "lines_to_next_cell": 1 + }, + "source": [ + "Then, define a function that creates a pretty graph:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "funded-protection", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "def SineAndCosineWaves():\n", + " # Get a large number of X values for a nice smooth curve. Using Pi as np.sin requires radians...\n", + " x = np.linspace(0, 2 * np.pi, 180)\n", + " # Convert radians to degrees to make for a meaningful X axis (1 radian = 57.29* degrees)\n", + " xdeg = 57.29577951308232 * np.array(x)\n", + " # Calculate the sine of each value of X\n", + " y = np.sin(x)\n", + " # Calculate the cosine of each value of X\n", + " z = np.cos(x)\n", + " # Plot the sine wave in blue, using degrees rather than radians on the X axis\n", + " pl.plot(xdeg, y, color='blue', label='Sine wave')\n", + " # Plot the cos wave in green, using degrees rather than radians on the X axis\n", + " pl.plot(xdeg, z, color='green', label='Cosine wave')\n", + " pl.xlabel(\"Degrees\")\n", + " # More sensible X axis values\n", + " pl.xticks(np.arange(0, 361, 45))\n", + " pl.legend()\n", + " pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "thorough-cutting", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "Finally, call that function to display the graph:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "imported-uruguay", + "metadata": {}, + "outputs": [], + "source": [ + "SineAndCosineWaves()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_markers": "\"\"\"" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..3cbe7f8 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,9 @@ +sphinx==6.1.3 +sphinx_rtd_theme==1.2.0 +sphinx-autoapi==2.0.1 +nbsphinx +ipython +jupytext +jupyter +matplotlib +numpy \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..822814f --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,53 @@ +[project] +name = "flexcode" +license = {file = "LICENSE"} +readme = "README.md" +authors = [ + { name = "Ann Lee", email = "annlee@andrew.cmu.edu" } +] +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Operating System :: OS Independent", + "Programming Language :: Python", +] +dynamic = ["version"] +dependencies = [ + "deprecated", + "ipykernel", # Support for Jupyter notebooks + "pywavelets", + "scikit-learn>=0.18", + "xgboost" +] + +# On a mac, install optional dependencies with `pip install '.[dev]'` (include the single quotes) +[project.optional-dependencies] +dev = [ + "pytest", + "pytest-cov", # Used to report total code coverage + "pre-commit", # Used to run checks before finalizing a git commit + "sphinx==6.1.3", # Used to automatically generate documentation + "sphinx_rtd_theme==1.2.0", # Used to render documentation + "sphinx-autoapi==2.0.1", # Used to automatically generate api documentation + "black", # Used for static linting of files + "nbconvert", # Needed for pre-commit check to clear output from Python notebooks + "nbsphinx", # Used to itegrate Python notebooks into Sphinx documentation + "ipython", # Also used in building notebooks into Sphinx + "matplotlib", # Used in sample notebook intro_notebook.ipynb + "numpy", # Used in sample notebook intro_notebook.ipynb +] + + +[build-system] +requires = [ + "setuptools>=45", # Used to build and package the Python project + "setuptools_scm>=6.2", # Gets release version from git. Makes it available programmatically +] +build-backend = "setuptools.build_meta" + +[tool.setuptools_scm] +write_to = "src/flexcode/_version.py" + +[tool.black] +line-length = 110 diff --git a/src/.pylintrc b/src/.pylintrc new file mode 100644 index 0000000..ac138f1 --- /dev/null +++ b/src/.pylintrc @@ -0,0 +1,626 @@ +[MAIN] + +# Analyse import fallback blocks. This can be used to support both Python 2 and +# 3 compatible code, which means that the block might have code that exists +# only in one or another interpreter, leading to false positives when analysed. +analyse-fallback-blocks=no + +# Clear in-memory caches upon conclusion of linting. Useful if running pylint +# in a server-like mode. +clear-cache-post-run=no + +# Load and enable all available extensions. Use --list-extensions to see a list +# all available extensions. +#enable-all-extensions= + +# In error mode, messages with a category besides ERROR or FATAL are +# suppressed, and no reports are done by default. Error mode is compatible with +# disabling specific errors. +#errors-only= + +# Always return a 0 (non-error) status code, even if lint errors are found. +# This is primarily useful in continuous integration scripts. +#exit-zero= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +extension-pkg-allow-list= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. (This is an alternative name to extension-pkg-allow-list +# for backward compatibility.) +extension-pkg-whitelist= + +# Return non-zero exit code if any of these messages/categories are detected, +# even if score is above --fail-under value. Syntax same as enable. Messages +# specified are enabled, while categories only check already-enabled messages. +fail-on= + +# Specify a score threshold under which the program will exit with error. +fail-under=10 + +# Interpret the stdin as a python script, whose filename needs to be passed as +# the module_or_package argument. +#from-stdin= + +# Files or directories to be skipped. They should be base names, not paths. +ignore=CVS + +# Add files or directories matching the regular expressions patterns to the +# ignore-list. The regex matches against paths and can be in Posix or Windows +# format. Because '\\' represents the directory delimiter on Windows systems, +# it can't be used as an escape character. +ignore-paths= + +# Files or directories matching the regular expression patterns are skipped. +# The regex matches against base names, not paths. +ignore-patterns=_version.py + +# List of module names for which member attributes should not be checked +# (useful for modules/projects where namespaces are manipulated during runtime +# and thus existing member attributes cannot be deduced by static analysis). It +# supports qualified module names, as well as Unix pattern matching. +ignored-modules= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook= + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use, and will cap the count on Windows to +# avoid hangs. +jobs=1 + +# Control the amount of potential inferred values when inferring a single +# object. This can help the performance when dealing with large functions or +# complex, nested conditions. +limit-inference-results=100 + +# List of plugins (as comma separated values of python module names) to load, +# usually to register additional checkers. +load-plugins= + +# Pickle collected data for later comparisons. +persistent=yes + +# Minimum Python version to use for version dependent checks. Will default to +# the version used to run pylint. +py-version=3.9 + +# Discover python modules and packages in the file system subtree. +recursive=no + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode=yes + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + +# In verbose mode, extra non-checker-related info will be displayed. +#verbose= + + +[BASIC] + +# Naming style matching correct argument names. +argument-naming-style=snake_case + +# Regular expression matching correct argument names. Overrides argument- +# naming-style. If left empty, argument names will be checked with the set +# naming style. +#argument-rgx= + +# Naming style matching correct attribute names. +attr-naming-style=snake_case + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. If left empty, attribute names will be checked with the set naming +# style. +#attr-rgx= + +# Bad variable names which should always be refused, separated by a comma. +bad-names=foo, + bar, + baz, + toto, + tutu, + tata + +# Bad variable names regexes, separated by a comma. If names match any regex, +# they will always be refused +bad-names-rgxs= + +# Naming style matching correct class attribute names. +class-attribute-naming-style=any + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. If left empty, class attribute names will be checked +# with the set naming style. +#class-attribute-rgx= + +# Naming style matching correct class constant names. +class-const-naming-style=UPPER_CASE + +# Regular expression matching correct class constant names. Overrides class- +# const-naming-style. If left empty, class constant names will be checked with +# the set naming style. +#class-const-rgx= + +# Naming style matching correct class names. +class-naming-style=PascalCase + +# Regular expression matching correct class names. Overrides class-naming- +# style. If left empty, class names will be checked with the set naming style. +#class-rgx= + +# Naming style matching correct constant names. +const-naming-style=UPPER_CASE + +# Regular expression matching correct constant names. Overrides const-naming- +# style. If left empty, constant names will be checked with the set naming +# style. +#const-rgx= + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + +# Naming style matching correct function names. +function-naming-style=snake_case + +# Regular expression matching correct function names. Overrides function- +# naming-style. If left empty, function names will be checked with the set +# naming style. +#function-rgx= + +# Good variable names which should always be accepted, separated by a comma. +good-names=i, + j, + k, + ex, + Run, + _ + +# Good variable names regexes, separated by a comma. If names match any regex, +# they will always be accepted +good-names-rgxs= + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint=no + +# Naming style matching correct inline iteration names. +inlinevar-naming-style=any + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. If left empty, inline iteration names will be checked +# with the set naming style. +#inlinevar-rgx= + +# Naming style matching correct method names. +method-naming-style=snake_case + +# Regular expression matching correct method names. Overrides method-naming- +# style. If left empty, method names will be checked with the set naming style. +#method-rgx= + +# Naming style matching correct module names. +module-naming-style=snake_case + +# Regular expression matching correct module names. Overrides module-naming- +# style. If left empty, module names will be checked with the set naming style. +#module-rgx= + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. +# These decorators are taken in consideration only for invalid-name. +property-classes=abc.abstractproperty + +# Regular expression matching correct type variable names. If left empty, type +# variable names will be checked with the set naming style. +#typevar-rgx= + +# Naming style matching correct variable names. +variable-naming-style=snake_case + +# Regular expression matching correct variable names. Overrides variable- +# naming-style. If left empty, variable names will be checked with the set +# naming style. +#variable-rgx= + + +[CLASSES] + +# Warn about protected attribute access inside special methods +check-protected-access-in-special-methods=no + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__, + __new__, + setUp, + __post_init__ + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict, + _fields, + _replace, + _source, + _make + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=mcs + + +[DESIGN] + +# List of regular expressions of class ancestor names to ignore when counting +# public methods (see R0903) +exclude-too-few-public-methods= + +# List of qualified class names to ignore when counting class parents (see +# R0901) +ignored-parents= + +# Maximum number of arguments for function / method. +max-args=5 + +# Maximum number of attributes for a class (see R0902). +max-attributes=7 + +# Maximum number of boolean expressions in an if statement (see R0916). +max-bool-expr=5 + +# Maximum number of branch for function / method body. +max-branches=12 + +# Maximum number of locals for function / method body. +max-locals=15 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body. +max-returns=6 + +# Maximum number of statements in function / method body. +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when caught. +overgeneral-exceptions=builtins.BaseException,builtins.Exception + + +[FORMAT] + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Maximum number of characters on a single line. +max-line-length=100 + +# Maximum number of lines in a module. +max-module-lines=1000 + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt=no + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + + +[IMPORTS] + +# List of modules that can be imported at any level, not just the top level +# one. +allow-any-import-level= + +# Allow explicit reexports by alias from a package __init__. +allow-reexport-from-package=no + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all=no + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules= + +# Output a graph (.gv or any supported image format) of external dependencies +# to the given file (report RP0402 must not be disabled). +ext-import-graph= + +# Output a graph (.gv or any supported image format) of all (i.e. internal and +# external) dependencies to the given file (report RP0402 must not be +# disabled). +import-graph= + +# Output a graph (.gv or any supported image format) of internal dependencies +# to the given file (report RP0402 must not be disabled). +int-import-graph= + +# Force import order to recognize a module as part of the standard +# compatibility libraries. +known-standard-library= + +# Force import order to recognize a module as part of a third party library. +known-third-party=enchant + +# Couples of modules and preferred modules, separated by a comma. +preferred-modules= + + +[LOGGING] + +# The type of string formatting that logging methods do. `old` means using % +# formatting, `new` is for `{}` formatting. +logging-format-style=old + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules=logging + + +[MESSAGES CONTROL] + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, +# UNDEFINED. +confidence=HIGH, + CONTROL_FLOW, + INFERENCE, + INFERENCE_FAILURE, + UNDEFINED + +# Disable the message, report, category or checker with the given id(s). You +# can either give multiple identifiers separated by comma (,) or put this +# option multiple times (only on the command line, not in the configuration +# file where it should appear only once). You can also use "--disable=all" to +# disable everything first and then re-enable specific checks. For example, if +# you want to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable=raw-checker-failed, + bad-inline-option, + locally-disabled, + file-ignored, + suppressed-message, + useless-suppression, + deprecated-pragma, + use-symbolic-message-instead, + missing-module-docstring, + unnecessary-pass, + + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where +# it should appear only once). See also the "--disable" option for examples. +enable=c-extension-no-member + + +[METHOD_ARGS] + +# List of qualified names (i.e., library.method) which require a timeout +# parameter e.g. 'requests.api.get,requests.api.post' +timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME, + XXX, + TODO + +# Regular expression of note tags to take in consideration. +notes-rgx= + + +[REFACTORING] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + +# Complete name of functions that never returns. When checking for +# inconsistent-return-statements if a never returning function is called then +# it will be considered as an explicit return statement and no message will be +# printed. +never-returning-functions=sys.exit,argparse.parse_error + + +[REPORTS] + +# Python expression which should return a score less than or equal to 10. You +# have access to the variables 'fatal', 'error', 'warning', 'refactor', +# 'convention', and 'info' which contain the number of messages in each +# category, as well as 'statement' which is the total number of statements +# analyzed. This score is used by the global evaluation report (RP0004). +evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +msg-template= + +# Set the output format. Available formats are text, parseable, colorized, json +# and msvs (visual studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +#output-format= + +# Tells whether to display a full report or only the messages. +reports=no + +# Activate the evaluation score. +score=yes + + +[SIMILARITIES] + +# Comments are removed from the similarity computation +ignore-comments=yes + +# Docstrings are removed from the similarity computation +ignore-docstrings=yes + +# Imports are removed from the similarity computation +ignore-imports=yes + +# Signatures are removed from the similarity computation +ignore-signatures=yes + +# Minimum lines number of a similarity. +min-similarity-lines=4 + + +[SPELLING] + +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions=4 + +# Spelling dictionary name. Available dictionaries: none. To make it work, +# install the 'python-enchant' package. +spelling-dict= + +# List of comma separated words that should be considered directives if they +# appear at the beginning of a comment and should not be checked. +spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy: + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains the private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to the private dictionary (see the +# --spelling-private-dict-file option) instead of raising a message. +spelling-store-unknown-words=no + + +[STRING] + +# This flag controls whether inconsistent-quotes generates a warning when the +# character used as a quote delimiter is used inconsistently within a module. +check-quote-consistency=no + +# This flag controls whether the implicit-str-concat should generate a warning +# on implicit string concatenation in sequences defined over several lines. +check-str-concat-over-line-jumps=no + + +[TYPECHECK] + +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators=contextlib.contextmanager + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + +# Tells whether to warn about missing members when the owner of the attribute +# is inferred to be None. +ignore-none=yes + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference +# can return multiple potential results while evaluating a Python object, but +# some branches might not be evaluated, which results in partial inference. In +# that case, it might be useful to still emit no-member and other checks for +# the rest of the inferred objects. +ignore-on-opaque-inference=yes + +# List of symbolic message names to ignore for Mixin members. +ignored-checks-for-mixins=no-member, + not-async-context-manager, + not-context-manager, + attribute-defined-outside-init + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace + +# Show a hint with possible names when a member name was not found. The aspect +# of finding the hint is based on edit distance. +missing-member-hint=yes + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance=1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices=1 + +# Regex pattern to define which classes are considered mixins. +mixin-class-rgx=.*[Mm]ixin + +# List of decorators that change the signature of a decorated function. +signature-mutators= + + +[VARIABLES] + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid defining new builtins when possible. +additional-builtins= + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables=yes + +# List of names allowed to shadow builtins +allowed-redefined-builtins= + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_, + _cb + +# A regular expression matching the name of dummy variables (i.e. expected to +# not be used). +dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ + +# Argument names that match this expression will be ignored. +ignored-argument-names=_.*|^ignored_|^unused_ + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io diff --git a/src/flexcode/basis_functions.py b/src/flexcode/basis_functions.py index 739d1be..8e326d1 100644 --- a/src/flexcode/basis_functions.py +++ b/src/flexcode/basis_functions.py @@ -2,8 +2,10 @@ import numpy as np import pywt -from .post_processing import * + from .helpers import box_transform, make_grid +from .post_processing import * + def evaluate_basis(responses, n_basis, basis_system): """Evaluates a system of basis functions. diff --git a/src/flexcode/core.py b/src/flexcode/core.py index b087871..bbc5b13 100644 --- a/src/flexcode/core.py +++ b/src/flexcode/core.py @@ -1,9 +1,9 @@ import numpy as np +from .basis_functions import BasisCoefs, evaluate_basis from .helpers import box_transform, make_grid -from .basis_functions import evaluate_basis, BasisCoefs -from .post_processing import * from .loss_functions import cde_loss +from .post_processing import * class FlexCodeModel(object): diff --git a/src/flexcode/helpers.py b/src/flexcode/helpers.py index 585bb1f..8b2f584 100644 --- a/src/flexcode/helpers.py +++ b/src/flexcode/helpers.py @@ -1,5 +1,6 @@ import numpy as np + def box_transform(z, z_min, z_max): """Projects z from box [z_min, z_max] to [0, 1] diff --git a/src/flexcode/loss_functions.py b/src/flexcode/loss_functions.py index 6dc4dcf..f390038 100644 --- a/src/flexcode/loss_functions.py +++ b/src/flexcode/loss_functions.py @@ -1,5 +1,6 @@ import numpy as np + def cde_loss(cde_estimates, z_grid, true_z): """Calculates conditional density estimation loss on holdout data diff --git a/src/flexcode/post_processing.py b/src/flexcode/post_processing.py index c6f9158..00919fb 100644 --- a/src/flexcode/post_processing.py +++ b/src/flexcode/post_processing.py @@ -1,6 +1,8 @@ import numpy as np + from .loss_functions import cde_loss + def normalize(cde_estimates, tol=1e-6, max_iter=200): """Normalizes conditional density estimates to be non-negative and integrate to one. diff --git a/src/flexcode/regression_models.py b/src/flexcode/regression_models.py index d3ee4ab..0312ca6 100644 --- a/src/flexcode/regression_models.py +++ b/src/flexcode/regression_models.py @@ -1,4 +1,5 @@ import numpy as np + from .helpers import params_dict_optim_decision, params_name_format try: @@ -9,10 +10,10 @@ try: import sklearn.ensemble - import sklearn.neighbors - import sklearn.multioutput - import sklearn.model_selection import sklearn.linear_model + import sklearn.model_selection + import sklearn.multioutput + import sklearn.neighbors SKLEARN_AVAILABLE = True except ImportError: SKLEARN_AVAILABLE = False diff --git a/tests/flexcode/.pylintrc b/tests/flexcode/.pylintrc new file mode 100644 index 0000000..c3cf2bf --- /dev/null +++ b/tests/flexcode/.pylintrc @@ -0,0 +1,627 @@ +[MAIN] + +# Analyse import fallback blocks. This can be used to support both Python 2 and +# 3 compatible code, which means that the block might have code that exists +# only in one or another interpreter, leading to false positives when analysed. +analyse-fallback-blocks=no + +# Clear in-memory caches upon conclusion of linting. Useful if running pylint +# in a server-like mode. +clear-cache-post-run=no + +# Load and enable all available extensions. Use --list-extensions to see a list +# all available extensions. +#enable-all-extensions= + +# In error mode, messages with a category besides ERROR or FATAL are +# suppressed, and no reports are done by default. Error mode is compatible with +# disabling specific errors. +#errors-only= + +# Always return a 0 (non-error) status code, even if lint errors are found. +# This is primarily useful in continuous integration scripts. +#exit-zero= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +extension-pkg-allow-list= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. (This is an alternative name to extension-pkg-allow-list +# for backward compatibility.) +extension-pkg-whitelist= + +# Return non-zero exit code if any of these messages/categories are detected, +# even if score is above --fail-under value. Syntax same as enable. Messages +# specified are enabled, while categories only check already-enabled messages. +fail-on= + +# Specify a score threshold under which the program will exit with error. +fail-under=10 + +# Interpret the stdin as a python script, whose filename needs to be passed as +# the module_or_package argument. +#from-stdin= + +# Files or directories to be skipped. They should be base names, not paths. +ignore=CVS + +# Add files or directories matching the regular expressions patterns to the +# ignore-list. The regex matches against paths and can be in Posix or Windows +# format. Because '\\' represents the directory delimiter on Windows systems, +# it can't be used as an escape character. +ignore-paths= + +# Files or directories matching the regular expression patterns are skipped. +# The regex matches against base names, not paths. +ignore-patterns=_version.py + +# List of module names for which member attributes should not be checked +# (useful for modules/projects where namespaces are manipulated during runtime +# and thus existing member attributes cannot be deduced by static analysis). It +# supports qualified module names, as well as Unix pattern matching. +ignored-modules= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook= + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use, and will cap the count on Windows to +# avoid hangs. +jobs=1 + +# Control the amount of potential inferred values when inferring a single +# object. This can help the performance when dealing with large functions or +# complex, nested conditions. +limit-inference-results=100 + +# List of plugins (as comma separated values of python module names) to load, +# usually to register additional checkers. +load-plugins= + +# Pickle collected data for later comparisons. +persistent=yes + +# Minimum Python version to use for version dependent checks. Will default to +# the version used to run pylint. +py-version=3.9 + +# Discover python modules and packages in the file system subtree. +recursive=no + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode=yes + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + +# In verbose mode, extra non-checker-related info will be displayed. +#verbose= + + +[BASIC] + +# Naming style matching correct argument names. +argument-naming-style=snake_case + +# Regular expression matching correct argument names. Overrides argument- +# naming-style. If left empty, argument names will be checked with the set +# naming style. +#argument-rgx= + +# Naming style matching correct attribute names. +attr-naming-style=snake_case + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. If left empty, attribute names will be checked with the set naming +# style. +#attr-rgx= + +# Bad variable names which should always be refused, separated by a comma. +bad-names=foo, + bar, + baz, + toto, + tutu, + tata + +# Bad variable names regexes, separated by a comma. If names match any regex, +# they will always be refused +bad-names-rgxs= + +# Naming style matching correct class attribute names. +class-attribute-naming-style=any + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. If left empty, class attribute names will be checked +# with the set naming style. +#class-attribute-rgx= + +# Naming style matching correct class constant names. +class-const-naming-style=UPPER_CASE + +# Regular expression matching correct class constant names. Overrides class- +# const-naming-style. If left empty, class constant names will be checked with +# the set naming style. +#class-const-rgx= + +# Naming style matching correct class names. +class-naming-style=PascalCase + +# Regular expression matching correct class names. Overrides class-naming- +# style. If left empty, class names will be checked with the set naming style. +#class-rgx= + +# Naming style matching correct constant names. +const-naming-style=UPPER_CASE + +# Regular expression matching correct constant names. Overrides const-naming- +# style. If left empty, constant names will be checked with the set naming +# style. +#const-rgx= + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + +# Naming style matching correct function names. +function-naming-style=snake_case + +# Regular expression matching correct function names. Overrides function- +# naming-style. If left empty, function names will be checked with the set +# naming style. +#function-rgx= + +# Good variable names which should always be accepted, separated by a comma. +good-names=i, + j, + k, + ex, + Run, + _ + +# Good variable names regexes, separated by a comma. If names match any regex, +# they will always be accepted +good-names-rgxs= + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint=no + +# Naming style matching correct inline iteration names. +inlinevar-naming-style=any + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. If left empty, inline iteration names will be checked +# with the set naming style. +#inlinevar-rgx= + +# Naming style matching correct method names. +method-naming-style=snake_case + +# Regular expression matching correct method names. Overrides method-naming- +# style. If left empty, method names will be checked with the set naming style. +#method-rgx= + +# Naming style matching correct module names. +module-naming-style=snake_case + +# Regular expression matching correct module names. Overrides module-naming- +# style. If left empty, module names will be checked with the set naming style. +#module-rgx= + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. +# These decorators are taken in consideration only for invalid-name. +property-classes=abc.abstractproperty + +# Regular expression matching correct type variable names. If left empty, type +# variable names will be checked with the set naming style. +#typevar-rgx= + +# Naming style matching correct variable names. +variable-naming-style=snake_case + +# Regular expression matching correct variable names. Overrides variable- +# naming-style. If left empty, variable names will be checked with the set +# naming style. +#variable-rgx= + + +[CLASSES] + +# Warn about protected attribute access inside special methods +check-protected-access-in-special-methods=no + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__, + __new__, + setUp, + __post_init__ + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict, + _fields, + _replace, + _source, + _make + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=mcs + + +[DESIGN] + +# List of regular expressions of class ancestor names to ignore when counting +# public methods (see R0903) +exclude-too-few-public-methods= + +# List of qualified class names to ignore when counting class parents (see +# R0901) +ignored-parents= + +# Maximum number of arguments for function / method. +max-args=5 + +# Maximum number of attributes for a class (see R0902). +max-attributes=7 + +# Maximum number of boolean expressions in an if statement (see R0916). +max-bool-expr=5 + +# Maximum number of branch for function / method body. +max-branches=12 + +# Maximum number of locals for function / method body. +max-locals=15 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body. +max-returns=6 + +# Maximum number of statements in function / method body. +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when caught. +overgeneral-exceptions=builtins.BaseException,builtins.Exception + + +[FORMAT] + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Maximum number of characters on a single line. +max-line-length=100 + +# Maximum number of lines in a module. +max-module-lines=1000 + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt=no + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + + +[IMPORTS] + +# List of modules that can be imported at any level, not just the top level +# one. +allow-any-import-level= + +# Allow explicit reexports by alias from a package __init__. +allow-reexport-from-package=no + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all=no + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules= + +# Output a graph (.gv or any supported image format) of external dependencies +# to the given file (report RP0402 must not be disabled). +ext-import-graph= + +# Output a graph (.gv or any supported image format) of all (i.e. internal and +# external) dependencies to the given file (report RP0402 must not be +# disabled). +import-graph= + +# Output a graph (.gv or any supported image format) of internal dependencies +# to the given file (report RP0402 must not be disabled). +int-import-graph= + +# Force import order to recognize a module as part of the standard +# compatibility libraries. +known-standard-library= + +# Force import order to recognize a module as part of a third party library. +known-third-party=enchant + +# Couples of modules and preferred modules, separated by a comma. +preferred-modules= + + +[LOGGING] + +# The type of string formatting that logging methods do. `old` means using % +# formatting, `new` is for `{}` formatting. +logging-format-style=old + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules=logging + + +[MESSAGES CONTROL] + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, +# UNDEFINED. +confidence=HIGH, + CONTROL_FLOW, + INFERENCE, + INFERENCE_FAILURE, + UNDEFINED + +# Disable the message, report, category or checker with the given id(s). You +# can either give multiple identifiers separated by comma (,) or put this +# option multiple times (only on the command line, not in the configuration +# file where it should appear only once). You can also use "--disable=all" to +# disable everything first and then re-enable specific checks. For example, if +# you want to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable=raw-checker-failed, + bad-inline-option, + locally-disabled, + file-ignored, + suppressed-message, + useless-suppression, + deprecated-pragma, + use-symbolic-message-instead, + missing-function-docstring, + redefined-outer-name, + protected-access, + missing-module-docstring, + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where +# it should appear only once). See also the "--disable" option for examples. +enable=c-extension-no-member + + +[METHOD_ARGS] + +# List of qualified names (i.e., library.method) which require a timeout +# parameter e.g. 'requests.api.get,requests.api.post' +timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME, + XXX, + TODO + +# Regular expression of note tags to take in consideration. +notes-rgx= + + +[REFACTORING] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + +# Complete name of functions that never returns. When checking for +# inconsistent-return-statements if a never returning function is called then +# it will be considered as an explicit return statement and no message will be +# printed. +never-returning-functions=sys.exit,argparse.parse_error + + +[REPORTS] + +# Python expression which should return a score less than or equal to 10. You +# have access to the variables 'fatal', 'error', 'warning', 'refactor', +# 'convention', and 'info' which contain the number of messages in each +# category, as well as 'statement' which is the total number of statements +# analyzed. This score is used by the global evaluation report (RP0004). +evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +msg-template= + +# Set the output format. Available formats are text, parseable, colorized, json +# and msvs (visual studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +#output-format= + +# Tells whether to display a full report or only the messages. +reports=no + +# Activate the evaluation score. +score=yes + + +[SIMILARITIES] + +# Comments are removed from the similarity computation +ignore-comments=yes + +# Docstrings are removed from the similarity computation +ignore-docstrings=yes + +# Imports are removed from the similarity computation +ignore-imports=yes + +# Signatures are removed from the similarity computation +ignore-signatures=yes + +# Minimum lines number of a similarity. +min-similarity-lines=4 + + +[SPELLING] + +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions=4 + +# Spelling dictionary name. Available dictionaries: none. To make it work, +# install the 'python-enchant' package. +spelling-dict= + +# List of comma separated words that should be considered directives if they +# appear at the beginning of a comment and should not be checked. +spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy: + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains the private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to the private dictionary (see the +# --spelling-private-dict-file option) instead of raising a message. +spelling-store-unknown-words=no + + +[STRING] + +# This flag controls whether inconsistent-quotes generates a warning when the +# character used as a quote delimiter is used inconsistently within a module. +check-quote-consistency=no + +# This flag controls whether the implicit-str-concat should generate a warning +# on implicit string concatenation in sequences defined over several lines. +check-str-concat-over-line-jumps=no + + +[TYPECHECK] + +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators=contextlib.contextmanager + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + +# Tells whether to warn about missing members when the owner of the attribute +# is inferred to be None. +ignore-none=yes + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference +# can return multiple potential results while evaluating a Python object, but +# some branches might not be evaluated, which results in partial inference. In +# that case, it might be useful to still emit no-member and other checks for +# the rest of the inferred objects. +ignore-on-opaque-inference=yes + +# List of symbolic message names to ignore for Mixin members. +ignored-checks-for-mixins=no-member, + not-async-context-manager, + not-context-manager, + attribute-defined-outside-init + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace + +# Show a hint with possible names when a member name was not found. The aspect +# of finding the hint is based on edit distance. +missing-member-hint=yes + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance=1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices=1 + +# Regex pattern to define which classes are considered mixins. +mixin-class-rgx=.*[Mm]ixin + +# List of decorators that change the signature of a decorated function. +signature-mutators= + + +[VARIABLES] + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid defining new builtins when possible. +additional-builtins= + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables=yes + +# List of names allowed to shadow builtins +allowed-redefined-builtins= + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_, + _cb + +# A regular expression matching the name of dummy variables (i.e. expected to +# not be used). +dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ + +# Argument names that match this expression will be ignored. +ignored-argument-names=_.*|^ignored_|^unused_ + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io diff --git a/tests/conftest.py b/tests/flexcode/conftest.py similarity index 100% rename from tests/conftest.py rename to tests/flexcode/conftest.py diff --git a/tests/context.py b/tests/flexcode/context.py similarity index 99% rename from tests/context.py rename to tests/flexcode/context.py index 342cdf3..a322724 100644 --- a/tests/context.py +++ b/tests/flexcode/context.py @@ -1,5 +1,6 @@ import os import sys + sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) import flexcode diff --git a/tests/test_cv_optim.py b/tests/flexcode/test_cv_optim.py similarity index 96% rename from tests/test_cv_optim.py rename to tests/flexcode/test_cv_optim.py index e3893d8..028629c 100644 --- a/tests/test_cv_optim.py +++ b/tests/flexcode/test_cv_optim.py @@ -13,10 +13,11 @@ import numpy as np import xgboost as xgb +from conftest import BUMP_THRESHOLD_GRID, SHARPEN_GRID, generate_data -from conftest import generate_data, BUMP_THRESHOLD_GRID, SHARPEN_GRID import flexcode -from flexcode.regression_models import NN, RandomForest, XGBoost, CustomModel, Lasso +from flexcode.regression_models import (NN, CustomModel, Lasso, RandomForest, + XGBoost) def test_coef_predict_same_as_predict_nn(): diff --git a/tests/test_models_fit.py b/tests/flexcode/test_models_fit.py similarity index 96% rename from tests/test_models_fit.py rename to tests/flexcode/test_models_fit.py index 2f6c964..5e4e984 100644 --- a/tests/test_models_fit.py +++ b/tests/flexcode/test_models_fit.py @@ -14,10 +14,12 @@ import numpy as np import pytest import xgboost as xgb +from conftest import BUMP_THRESHOLD_GRID, SHARPEN_GRID, generate_data -from conftest import generate_data, BUMP_THRESHOLD_GRID, SHARPEN_GRID import flexcode -from flexcode.regression_models import NN, RandomForest, XGBoost, Lasso, CustomModel +from flexcode.regression_models import (NN, CustomModel, Lasso, RandomForest, + XGBoost) + @pytest.mark.skip(reason="The assertion is meaningless and the test is a duplicate") def test_example(): diff --git a/tests/test_params_handling.py b/tests/flexcode/test_params_handling.py similarity index 99% rename from tests/test_params_handling.py rename to tests/flexcode/test_params_handling.py index 5336277..716cd59 100644 --- a/tests/test_params_handling.py +++ b/tests/flexcode/test_params_handling.py @@ -1,7 +1,9 @@ -import pytest import numpy as np +import pytest + from flexcode.helpers import params_dict_optim_decision + def test_params_transform(): dict1 = {'k': [1, 2, 3, 4, 5, 6]} diff --git a/tests/test_post_processing.py b/tests/flexcode/test_post_processing.py similarity index 99% rename from tests/test_post_processing.py rename to tests/flexcode/test_post_processing.py index 4aa13bc..2a0eb5c 100644 --- a/tests/test_post_processing.py +++ b/tests/flexcode/test_post_processing.py @@ -1,8 +1,10 @@ import numpy as np import pytest from context import flexcode + from flexcode.post_processing import * + def test_remove_bumps(): density = np.ones(100) density[4] = 0.0 diff --git a/tutorial/Flexcode-tutorial-teddy.ipynb b/tutorial/Flexcode-tutorial-teddy.ipynb index 6c953d1..c5035a3 100644 --- a/tutorial/Flexcode-tutorial-teddy.ipynb +++ b/tutorial/Flexcode-tutorial-teddy.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -87,34 +87,18 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extraction and Saving Done!\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "extract_teddy_data(filename='data/teddy_A.txt', train_data=True, directory='data/')" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extraction and Saving Done!\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "extract_teddy_data(filename='data/teddy_B.txt', train_data=False, directory='data/')" ] @@ -149,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -188,7 +172,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -213,7 +197,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -230,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -240,27 +224,9 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'max_basis': 31,\n", - " 'best_basis': range(0, 31),\n", - " 'basis_system': 'cosine',\n", - " 'model': ,\n", - " 'z_min': array([0.127902]),\n", - " 'z_max': array([0.915344]),\n", - " 'bump_threshold': None,\n", - " 'sharpen_alpha': None}" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "model.__dict__" ] @@ -275,18 +241,9 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " (500, 1000)\n", - "Integral of the first density integrates to: 1.00\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from scipy.integrate import simps\n", "\n", @@ -312,17 +269,9 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CDE Loss: -12.20 \\pm 0.48\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "cde_loss_val, std_cde_loss = cde_loss(cde_test, z_grid, z_test)\n", "print('CDE Loss: %4.2f \\pm %.2f' % (cde_loss_val, std_cde_loss))" @@ -337,24 +286,9 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "fig = plt.figure(figsize=(30, 20))\n", "for jj, cde_predicted in enumerate(cde_test[:12,:]):\n", @@ -387,17 +321,9 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best Bump Removal Threshold: 0.05\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "threshold_vec = [5e-2, 1e-1, 5e-1]\n", "model.tune(x_validation, z_validation, bump_threshold_grid=threshold_vec, n_grid=n_grid)\n", @@ -413,7 +339,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -422,17 +348,9 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CDE Loss: -12.30 \\pm 0.51\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "cde_loss_val, std_cde_loss = cde_loss(cde_test, z_grid, z_test)\n", "print('CDE Loss: %4.2f \\pm %.2f' % (cde_loss_val, std_cde_loss))" @@ -440,24 +358,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "fig = plt.figure(figsize=(30, 20))\n", "for jj, cde_predicted in enumerate(cde_test[:12,:]):\n", @@ -489,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -506,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -528,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -552,20 +455,9 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "np.max(np.abs(cdes_predict_custom - cdes_predict_xgb))" ] @@ -593,7 +485,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -617,21 +509,9 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "fig_pit = plot_with_uniform_band(values=pit_values, ci_level=0.99, x_label='PIT Values', n_bins=30)\n", "fig_pit" @@ -639,21 +519,9 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAEaCAYAAAA8FXKrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3de5xd47348c83twmRkEgQJYJUih8tRjnaEuqgbg1RGlQuQjlOo4dSNKd6Sn8/dTuOu5BKI3WvuLZKNNJTxy3EpaFVTtK0lOZ+IXJ9fn+sPTGXHdkze01mz8zn/Xqt15r9rGet9d2zZmZ/53me9axIKSFJkqR8dGjpACRJktoSkytJkqQcmVxJkiTlyORKkiQpRyZXkiRJOTK5kiRJylFJyVVEDIqIVGRZWK9ez4i4LSLmRsSHETE5InZrntAlSZIqT6dG1h8NvFjr9aqaLyIigEeA/sB3gAXAhcCUiPhCSulv5YUqSZJU+RqbXL2ZUnpuHduOBr4EHJRSmgIQEc8CM4HzyRIzSZKkNi3PMVdHA+/VJFYAKaVFZK1ZX8/xPJIkSRWrscnVLyJidUTMi4g7I6JfrW27An8oss8MoF9EbNLkKCVJklqJUrsFFwFXAVOBxcAewEXAsxGxR0rpH0AvYFaRfecX1j2BpfU3RsTpwOkA3bp12+tzn/tcY+KXJElqES+99NLclFKf+uUlJVcppenA9FpFUyPid8ALZGOpxjQ1sJTSWGAsQHV1dZo2bVpTDyVJkrTBRMRfipU3ecxVSull4C1g70LRArLWqfp61douSZLUpuUxoD0V1jPIxl3VtwswO6XUoEtQkiSprWlychUR1cBAsq5BgIeBz0TEAbXq9ACOKmyTJElq80oacxURvyCbr+plYCHZgPYLgXeBawvVHgaeBSZGxHl8MoloAJfnG7YkSVJlKvVuwT8AQ8lmXt8YeB94ALg4pTQXIKW0JiKOBK4EbgS6kiVbB6aU/pp34JIkSZUoUkrrr7WBeLegJElqLSLipZRSdf3yPGdolyRJavca+2xBSVKFWL58OfPnz2fJkiWsXr26pcORWr2OHTvSvXt3evXqRVVVVZOPY3IlSa3Q8uXLmT17Nj179qR///507tyZiGjpsKRWK6XEypUrWbx4MbNnz6Zfv35NTrDsFpSkVmj+/Pn07NmT3r1706VLFxMrqUwRQZcuXejduzc9e/Zk/vz5699pHUyuJKkVWrJkCT169GjpMKQ2qUePHixZsqTJ+5tcSVIrtHr1ajp37tzSYUhtUufOncsax2hyJUmtlF2BUvMo93fL5EqSJClHJleSJEk5MrmSJLV7w4cPL9oVNGXKFPbdd1+6d+9ORDB+/PgNH5xaHZMrSVJFGz9+/KcmNrNmzSIiGD58eK7nXbBgAcceeywffvghV111FXfccQf7779/rufYUE444QQigq9+9astHUq74CSikqR279Zbb+Xmm2+uU/biiy+ycOFCxo0bx7HHHttCkZVv3rx5PPjgg+y4445MmTKFWbNm0b9//5YOq02z5UqS1O517tyZrl271il7//33AejVq1eu51q9ejUfffRRrsf8NBMnTmTlypXcc889dOrUidtvv32DnbuYcuaPai1MriRJbU5NV+GPfvQjHn30Ufbee2+6du1K3759Oe+881i1alWd+vXHXPXv359hw4YBcOCBBxIRdbbPnTuXs846i2233ZYuXbqw7bbbctZZZzFv3rw6x63p0pw8eTKXXHIJO+64I127duXee+/l6aefXtvdeeONNzJw4EC6du3KbrvtxqOPPgrA66+/zmGHHUaPHj3YfPPNGT16NCtXrmzU92LcuHEMGjSIvfbaiyOPPJLx48ezZs2atdu///3vExG89tprDfZdtGgRG220EYMHD65TPnnyZA455BA222wzunbtyu67796g5a/m+zho0CCmT5/OoYceyqabbsruu+8OZEnWmDFj2GeffejduzdVVVUMGDCACy64oGjyOW/ePEaOHMnmm2/OJptswkEHHcT06dMZNGhQ0Za4adOmccwxx6w99sCBA/nJT37S4No3B7sFJUlt1q9+9StuvPFGzjjjDEaOHMlDDz3ElVdeSc+ePbnooovWud8111zDr3/9a8aOHctFF13EzjvvvHbbokWL2G+//Xj77bcZOXIke+65J9OnT+emm27it7/9LS+88ALdu3evc7zvfe97rFy5ktNOO40ePXowcOBAli9fDsANN9zAggULGDVqFF27duXaa6/lmGOO4b777uO0005j6NChDB48mCeeeILrrruOLbbYgjFjxpT0/l988UVef/31tePVhg8fzqRJk9YmRwDDhg3j8ssvZ8KECVx55ZV19r/33nv5+OOP1yaaAGPHjuWMM85g33335Qc/+AHdunXjySef5Mwzz+Sdd97hiiuuqHOM2bNnc9BBB/GNb3yDIUOGsHTpUgDeffddbrvtNoYMGcKJJ55Ip06dmDp1KpdffjnTp0/nN7/5zdpjLF++nIMPPphXXnmF4cOH88UvfpHXXnuNgw8+uGjL4mOPPcaxxx7LgAEDOPfcc+nVqxfPPvssP/zhD3nllVe47777Svr+NVlKqWKWvfbaK0mS1u+NN94ovuHss1M64IDKWs4+u6z3evvttycg3X777UW3z5w5MwFp2LBhDco23njjNHPmzLXla9asSbvuumvaaqut6hxj2LBhKftIbHjeKVOm1Cm/6KKLEpBuuOGGOuXXX399AtKYMWMaHGOnnXZKH374YZ36U6ZMSUDaeuut08KFC9eWv/rqqwlIEZF++ctf1tlnzz33bBD7pznjjDNSt27d0pIlS1JKKa1YsSL16dMnHX/88XXqVVdXp759+6ZVq1bVKf/yl7+cNt9887R8+fKUUkrvvfdeqqqqSkOHDm1wrtGjR6cOHTqkd955Z23Zdtttl4B06623Nqi/fPnytGLFigblY8aMSUB6/vnn15bdcMMNCUiXXnppnbo15dttt93asmXLlqUtt9wyfeUrX0krV66sU//qq68uek2LWefvWC3AtFQkn7FbUJLUZg0ePLhOl1FEcOCBB/L++++vbUFprEmTJtGnTx9OP/30OuXf/va36dOnD5MmTWqwz5lnnsnGG29c9HjDhw9n0003Xft69913p0ePHmy99dYNBtJ/+ctfLjn2ZcuWcddddzFkyBA22WQTIBtbdtJJJ/HQQw/VeTDxsGHD+Pvf/86TTz65tmzmzJk888wzDB06lC5dugBw//33s3z5ck499VTmzp1bZznqqKNYs2YNkydPrhNHr169GDFiRIP4unTpsvYRTqtWrWLBggXMnTuXgw8+GIDnn39+bd1HHnmEjh07cvbZZ9c5xqhRo+p87wCefPJJPvjgA0aMGMHChQvrxHj44YcD8MQTT6z3+1cOuwUlqS255pqWjqDFFJunaocddmhQtvnmmwPZGJ6apKMxZs6cSXV1NZ061f0I7dSpEzvttBMvv/xyg3122mmndR6vWIw9e/Zk2223LVoOpcV+//33s2jRIg444ADefvvtteX7778/11xzDRMnTmT06NEADB06lHPPPZcJEyZw2GGHATBhwgRSSpxyyilr933zzTcB1iZAxXzwwQd1Xu+444507NixaN0bb7yRm2++mRkzZtQZBwbZVBg1Zs6cydZbb93gPXfp0oXtt9++Tt2aGEeOHFlyjHkzuZIkVbSNNtoIYJ132H344Yd16tW2rg91yIbFbCjrarWCdcdYbuzjxo0D4NRTTy26/Wc/+9na5GrzzTfn8MMP58EHH2TJkiV0796dO+64g5133pm99967wXknTJhA3759ix63frK4rvd+9dVXc+6553LIIYcwevRott56a7p06cK7777L8OHDGyRbpaqJ8YorruALX/hC0Tpbb711k45dKpMrSVJF23777YFPWiTqqymvqdfcdthhB/70pz+xatWqOq1Xq1at4q233iraErWhvfPOO/zud7/jpJNOanCnH8BTTz3FzTffzEsvvcRee+0FZF2DDz74IPfddx8DBw7knXfe4bLLLquz32c/+1kAevfu/amtV6W444476N+/P7/+9a/p0OGTUUqPP/54g7r9+/dn8uTJLF26tE7r1cqVK5k5cyabbbZZgxi7detWdoxN5ZgrSVJF23PPPdl22225++67ee+99+psW7FiBddffz0RwdFHH71B4hk8eDBz5szhtttuq1N+6623MmfOHI455pgNEsen+dnPfkZKiXPOOYfjjjuuwfL9739/bb0aRxxxBL1792bChAlMmDCBDh06cPLJJ9c57vHHH09VVRUXX3wxy5Yta3DeRYsWrb0Lcn06duxIRNRphVu1alWDhA7gqKOOYvXq1fzXf/1XnfJbb72VRYsW1Sk79NBD2WKLLbjsssvqjCursWzZsmafa8uWK0lSRevUqRM33XQTxxxzDLvvvjunnnoqO+64Ix988AH33HMPM2bM4KKLLmLgwIEbJJ7zzz+f++67j7POOouXX36ZPfbYg+nTpzNu3DgGDhzI+eefv0HiWJfVq1czfvx4+vfvz5577lm0Tv/+/dlrr7248847ueqqq+jatSudO3dm6NChXH/99bz00kscfPDBfOYzn6mz3zbbbMNNN93EqFGj2HnnnfnWt77Fdtttx5w5c3j99dd58MEHeeONN0qaAf64447jwgsv5Gtf+xrHHnssixcv5s4771w7yL22UaNGccsttzBmzBjefvvttVMx3HvvvQwYMKDO3FXdunVjwoQJDB48mIEDBzJy5EgGDBjAwoUL+eMf/8gDDzzApEmTGDRoUKO+r41hciVJqnhHHHEEzzzzDJdffjk///nPmTdvHt26dWOPPfbgnnvu4fjjj99gsWy66aY888wzXHzxxTz88MPcfvvtbLnllpxxxhn8x3/8R4M5rja0xx9/nPfee49zzjnnU+sNGTKEiy66iAceeIATTzwRyLoGr7vuOpYuXVpnIHttI0aMYKedduLKK6/klltuYeHChfTu3ZuBAwdyySWXsNVWW5UU53nnnUdKiXHjxnH22Wez1VZbccIJJzBixAh22WWXOnWrqqp46qmnOO+883jooYe499572WeffXjqqacYNWpUg/F4hx56KC+++CKXXXYZEydOZM6cOfTs2ZMdd9yRc845Z+1Eps0lNuSAvvWprq5O06ZNa+kwJKnivfnmm3UmtpTao9WrV9O7d2/22WefomO1ylHK71hEvJRSqq5f7pgrSZJU8YqN8br55ptZuHAh//zP/9wCEa2b3YKSJKninXbaaXz88cfst99+VFVV8eyzz3LnnXcyYMCABhO6tjRbriRJUsU75JBD+Otf/8oll1zCd7/7XZ5++mlGjRrF73//+xYf51afLVeSJKninXLKKescZF9pbLmSJEnKkcmVJElSjkyuJKmVqqSpdKS2pNzfrSYlVxHxeESkiLi0XnnPiLgtIuZGxIcRMTkidisrQklSAx07dmTlypUtHYbUJq1cufJTH5y9Po1OriJiKPD5IuUBPAIcBnwHGAJ0BqZExDZNjlCS1ED37t1ZvHhxS4chtUmLFy8u6w7ERiVXEdET+E+g2Jz6RwNfAr6VUrorpfR4oawD0LIPWpKkNqZXr14sWLCAuXPnsmLFCrsIpTKllFixYgVz585lwYIF9OrVq8nHauxUDD8F/pBSuisi7qy37WjgvZTSlFqBLoqIR4CvA6ObHKUkqY6qqir69evH/PnzmTVrFqtXr27pkKRWr2PHjnTv3p1+/fpRVVXV5OOUnFxFxJeBUyjSJViwK/CHIuUzgFMiYpOU0tLGhyhJKqaqqoq+ffvSt2/flg5FUi0ldQtGRBfgFuDKlNKf1lGtF7CgSPn8wrrnOo59ekRMi4hpc+bMKSUcSZKkilXqmKvzgY2An+QdQEppbEqpOqVU3adPn7wPL0mStEGtt1swIvoBPwBGAVURUbsTsioiNgOWkLVaFWudqhkRVqxVS5IkqU0ppeVqB6ArMJEsQapZAL5X+Ho3srFVuxbZfxdgtuOtJElSe1DKgPZXgAOLlE8hS7jGAW8DDwMjIuKAlNJUgIjoARwF1L+zUJIkqU1ab3KVUloIPF2/PJszlL+klJ4uvH4YeBaYGBHnkbVoXQgEcHluEUuSJFWw3J4tmFJaAxwJPAncCEwCVgMHppT+mtd5JEmSKlljJxFdK6UURcrmAyMLiyRJUruTW8uVJEmSTK4kSZJyZXIlSZKUI5MrSZKkHJlcSZIk5cjkSpIkKUcmV5IkSTkyuZIkScqRyZUkSVKOTK4kSZJyZHIlSZKUI5MrSZKkHJlcSZIk5cjkSpIkKUcmV5IkSTkyuZIkScqRyZUkSVKOTK4kSZJy1KmlA5AkSarR/4LHyj7GrMuOyCGSprPlSpIkKUcmV5IkSTkyuZIkScpRuxtz1Rb6ciVJUuWy5UqSJClHJleSJEk5MrmSJEnKkcmVJElSjkyuJEmScmRyJUmSlCOTK0mSpByVlFxFxKER8duIeD8ilkfE3yLi3ojYpV69bSPi/ohYFBGLI+KBiOjXPKFLkiRVnlInEe0FvATcCMwB+gEXAM9FxG4ppb9ExMbAb4HlwDAgAZcCUyJi95TSh7lHL0mSVGFKSq5SSncBd9Uui4gXgD8CxwFXAacBOwADU0pvF+q8BvwZ+DZwdX5hS5IkVaZyxlzNK6xXFdZHA8/VJFYAKaWZwDPA18s4jyRJUqvRqOQqIjpGRJeI+CxwC/A+n7Ro7Qr8ochuM4BdipRLkiS1OY1tuXqebEzVW8DuwEEppX8UtvUCFhTZZz7Qc10HjIjTI2JaREybM2dOI8ORJEmqLI1Nrr4F7AucCCwGnoyI/uUEkFIam1KqTilV9+nTp5xDSZIktbhGJVcppTdTSs8XBrh/FdiE7K5ByFqtirVQratFS5Ikqc1p8oD2lNJC4G1gQKFoBtm4q/p2Ad5o6nkkSZJakyYnVxGxJfA54J1C0cPAvhGxQ606/YEvFbZJkiS1eSXNcxURk4CXgdfIxlrtBPwb2TQMVxWq3Qr8K/BQRIwhm0T0EuCvZHcWSpIktXmltlw9BwwGfg48BpwDTAW+kFJ6C6AwA/tBZHcS3gH8AphJdkfh0pzjliRJqkilztD+U+CnJdSbDQwpNyhJkqTWqtRnC24Q8+bNY/z48c16jsO6zFt/pfUYP975uCRJag5t4XO6opKr1mLZsmUtHYIkSVqH5cuXU1VV1WLnj5RSi528vurq6jRt2rRmPUf/Cx4r+xj/M3qPHCKRJEn17Xft9LKPMXnUQAYMGLD+imWKiJdSStX1y8t5cLMkSZLqMbmSJEnKkcmVJElSjkyuJEmScmRyJUmSlCOTK0mSpByZXEmSJOXI5EqSJClHJleSJEk5MrmSJEnKkcmVJElSjnxwcyuWx/OXfE6iJEn5suVKkiQpRyZXkiRJOTK5kiRJypHJlSRJUo5MriRJknJkciVJkpQjkytJkqQcmVxJkiTlyElE27lyJyJ1EtLK5ASzktRybLmSJEnKkcmVJElSjkyuJEmScmRyJUmSlCOTK0mSpByZXEmSJOXI5EqSJClH653nKiKOA4YC1cAWwGzgAeD/ppSW1KrXE7gCGAxsBDwL/FtK6fVmiLtFOYdQ5fGaSJIqRSktV98DVgMXAYcBNwFnAk9GRAeAiAjgkcL27wBDgM7AlIjYphniliRJqkilzNB+VEppTq3XUyNiPvBzYBDwW+Bo4EvAQSmlKQAR8SwwEzgfGJ1n0JIkSZVqvS1X9RKrGi8W1p8prI8G3qtJrAr7LSJrzfp6uUFKkiS1Fk0d0H5AYf1mYb0r8Ici9WYA/SJikyaeR5IkqVVp9IObI+IzwI+BySmlaYXiXsCsItXnF9Y9gaXrON7pwOkA/fr1a2w4agPyGIyu/HmTgCQ1TaNargotUA8Bq4AReQSQUhqbUqpOKVX36dMnj0NKkiS1mJJbriJiI7IxVDsAB6SU/lZr8wKy1qn6etXaLkmS1OaV1HIVEZ2B+8nmujq8yNxVM8jGXdW3CzA7pVS0S1CSJKmtKWUS0Q7AL4CDgCNTSs8VqfYwMCIiDkgpTS3s1wM4Crgzx3ilZuMYI0lSHkrpFrwB+AbwE+DDiNi31ra/FboHHyabkX1iRJxH1g14IRDA5fmGLEmSVLlK6Rb8WmH9A7IEqvYyCiCltAY4EngSuBGYRDar+4Eppb/mHLMkSVLFWm/LVUqpfykHSinNB0YWFkmSpHapqZOISpIkqYhGTyKqfDhxptqDSvk590aDfHnzh/TpbLmSJEnKkcmVJElSjkyuJEmSchQppZaOYa3q7t3TtL32atZzPPe/85r1+O3NHtt0L/sY0/+2JIdIKoPfj8qUx3XRJ/L4GfWaaF3y+Pn6fN+N2WijjXKI5tPF1KkvpZSq65fbciVJkpSjyrpbcOBAePrpZj3FNy94rFmP397kccfPNyvkjrI8+P2oTN6Zlq88fka9JlqXPH6+Jo8ayIABA3KIZj0iihbbciVJkpSjymq5klq5SpnXSZLUcmy5kiRJypHJlSRJUo5MriRJknJkciVJkpQjkytJkqQcmVxJkiTlyORKkiQpRyZXkiRJOXISUUltXrmTu1bKo1rymKS2Ut6LKo+TIOfHlitJkqQcmVxJkiTlyORKkiQpR465kqR2xHE1UvOz5UqSJClHJleSJEk5MrmSJEnKkcmVJElSjhzQrrI4OFZSS3FSVVUqW64kSZJyZHIlSZKUo5KSq4jYJiKui4hnI+KjiEgR0b9Iva4RcUVE/D0ilhXq75930JIkSZWq1DFXA4DjgZeA/wYOWUe9ccARwHnA/wJnAb+JiH9KKb1SZqySpDaiUsZrOm5LzaHU5Op3KaUtASJiFEWSq4j4PHAiMDKldHuhbCowA/gxcHQuEUuSJFWwkroFU0prSqh2NLASuKfWfquAu4FDI6KqSRFKkiS1InkOaN8VmJlS+qhe+QygC1nXoiRJUpuW5zxXvYAFRcrn19reQEScDpwO0K9fvxzDkSSpdXDsV9vS4lMxpJTGppSqU0rVffr0aelwJEmSypJncrUA6FmkvKbFan6RbZIkSW1KnsnVDGD7iNi4XvkuwArg7RzPJUmSVJHyTK4eAToD36gpiIhOwAnAEyml5TmeS5IkqSKVPKA9Io4rfLlXYf21iJgDzEkpTU0pTY+Ie4BrIqIzMBM4E9geOCnPoCVpQ3KwsaTGaMzdgvfVe31jYT0VGFT4egTwE+BSYDPgVeCwlNLLZcQoSZLUapScXKWUooQ6y4BzCoskSVK70+JTMUiSJLUleU4iKkmSWkilPAxbtlxJkiTlyuRKkiQpRxXVLThv3jzGjx/frOc4rMu8Zj2+JBXz6KPvln2Mw7osySES5c1rW3mefHI2v//971vs/BWVXElSW/Xy3/zwbKu8tpWnQ4eW7ZiLlFKLBlBbdXV1mjZtWrOeo/8FjzXr8SVJUsuaddkRG+Q8EfFSSqm6frljriRJknJkciVJkpQjkytJkqQcmVxJkiTlyORKkiQpRyZXkiRJOTK5kiRJypHJlSRJUo5MriRJknJkciVJkpQjkytJkqQcmVxJkiTlyORKkiQpRyZXkiRJOTK5kiRJypHJlSRJUo5MriRJknJkciVJkpQjkytJkqQcmVxJkiTlyORKkiQpRyZXkiRJOTK5kiRJypHJlSRJUo5yTa4iYtuIuD8iFkXE4oh4ICL65XkOSZKkSpZbchURGwO/BT4HDAO+BXwWmBIR3fI6jyRJUiXrlOOxTgN2AAamlN4GiIjXgD8D3wauzvFckiRJFSnPbsGjgedqEiuAlNJM4Bng6zmeR5IkqWLlmVztCvyhSPkMYJcczyNJklSx8uwW7AUsKFI+H+i5rp0i4nTg9MLLpRHxpxxjKqY3MLeZz6HG8ZpUJq9L5fGaVCavS4WJn26wa7JdscI8k6smSSmNBcZuqPNFxLSUUvWGOp/Wz2tSmbwulcdrUpm8LpWnpa9Jnt2CCyjeQrWuFi1JkqQ2J8/kagbZuKv6dgHeyPE8kiRJFSvP5OphYN+I2KGmICL6A18qbKsUG6wLUiXzmlQmr0vl8ZpUJq9L5WnRaxIppXwOlE0U+iqwDBgDJOASoDuwe0ppaS4nkiRJqmC5tVyllD4EDgLeAu4AfgHMBA4ysZIkSe1Fbi1XkiRJyvnBzS2lnAdGR0TXiLgiIv4eEcsi4tmI2L+5Y24PmnpdIqI6IsZGxB8j4qOImB0Rv4iI7TdE3G1ZXg9Xj4gLIiJFxO+bI872ptzrEhE7R8R9ETG38HfsTxFxdnPG3NaV+bnSLyJ+XvjbtSwi3oqIS33ObnkiYpuIuK7wOf1R4W9Q/xL37RARF0bErIj4OCJejYghzRVrq0+ucnhg9Diy5yL+EDgS+Dvwm4j4QvNE3D6UeV2+SXbn6bXA14ALgD2BaRGxbbMF3cbl9XD1wk0rY4B/NEec7U251yUiqoHngSpgFHA4cBXQsblibuvKuSaF7ZOB/YF/J7setwHnAj9rxrDbgwHA8WTTO/13I/e9BPgRcD3Z58pzwH0RcXieAa6VUmrVC3A2sBoYUKtse2AVcM569v082cD7EbXKOgF/Ah5u6ffWmpcyr0ufImXbAWuAH7f0e2utSznXpN5xfgPcAjwN/L6l31drX8r8XelANtXNpJZ+H21pKfOaHFL4XDmkXvllhf03bun311oXoEOtr0cVvs/9S9hvC2A58B/1yp8CXmuOWFt9yxXlPTD6aGAlcE+tfVcBdwOHRkRV/uG2G02+LimlOUXK/gLMAT6Tc5ztSdkPV4+IE8laES9slgjbp3KuyyBgZ+DqZouufSrnmnQprBfXK19IlgxHXkG2NymlNU3c9VCy6zKxXvlEYLfmGHLSFpKrch4YvSswM6X0UZF9u5A1Qappcn2Qd0TsTPbfx5tlxtWelXVNIqIn8J/A+Sml+TnH1p6Vc12+XFh3jYjnImJlRPwjIq6NiI1yjbJ9KeeaTAb+DPw0InaJiE0i4iCy1rCbU3ZnvTasXclart6uVz6jsG70Z9L6tIXkqkkPjC5h35rtappyrksdEdEJuJms5c9rTxkAAAkrSURBVGpc+aG1W+VekyvIploZn2NMKu+6bF1Y3wM8AfwzcDlZl8mdeQXYDjX5mqSUPiZLejuQfXgvIet+ehT413zDVIl6AQtToS+wlmb7rG/xBzdLJbge2A84IqXkcypbQER8BTgF2LPIHyi1nJp/kCemlH5Y+PrpiOgIXBYRO6eUbO3dgCKiK1myuwXZQPjZwBfJbppaBZzZctFpQ2kLyVU5D4xeQDZQuti+8ElWq8bL5UHeEXEZcDowLKX0RE6xtVflXJNbyFoN/xYRmxXKOgEdC6+XpZSW5xZp+1LOdZlXWD9Zr/wJsgHUe2BXelOUc01OJRsLNyCl9E6h7HcRsQgYGxE3p5RezS1SlWIBsFlERL1/Dpvts74tdAuW88DoGcD2hdtu6++7gob9sypd2Q/yjogfAN8HRqeU7sgxtvaqnGuyM3AG2R+pmuVLwL6Fr/1vvOnK/Rv2aZo6ALi9K+ea7AYsqJVY1XihsN65zNjUeDPIpirZsV55zVirkj6TGqMtJFflPDD6EaAz8I1a+3YCTgCe8D/xspT1IO+IGA1cCvwgpXR9M8XY3pRzTQ4ssrxKNuj3QOD+/MNtN8q5Lr8mG6h7aL3ywwrrafmE2O6Uc03eB3pGRP0bovYprN/NKUaV7nGymQFOqld+MvCHwp2g+WrpeStymPeiG1kL0+tkt8geTfZH/3+BTWrV246sv/uH9fa/m+w/71HAV8k+JD4mG1vS4u+vtS7lXBeySUTXkH1w7Ftv2aWl31trXcr9XSlyvKdxnqsWvy7AxYXy/wscTDbp7jJgfEu/t9a6lPn3qz/ZNAxvkU1AeiBwXqFsGrXmanJp0rU5rrDcRDbP1ZmF1wfUqrMKGFdvv8sKn+3nkHXb3lT4nDmyWeJs6W9UTt/sfsAvCz+8S4AHqTexWOEHPgE/qle+EdkcMe8XvvHPA4Na+j21haWp14XsbrS0juXpln5frXkp53elyLFMrirgupDNm3ROIRlYAfwF+DHQuaXfV2teyrwmuwD3An8lS3TfAq4Eerb0+2rtSymfDYXX4+vt15HsyRJ/IWvtfQ04rrni9MHNkiRJOWoLY64kSZIqhsmVJElSjkyuJEmScmRyJUmSlCOTK0mSpByZXEmSJOXI5EqSShART0eEc9dIWi+TK0lERFpf4hARswr1+q+jvGZZExELI+J/IuKswiOlPq3+yoiYFxGvR8QdEfGNiOjSiNifKRzn8BLq/qlQd49Sjy9JjdVp/VUkqST/BSwkmwl5e2AI8E9kj5U69lPqdwB6AAOBY8ie9/XniDg5pfRCkf3quxXYj+wRVr9aV6WIOADYCZiWUppe4nuSpEYzuZKUl2tSSrNqXkTE/wNeBI6JiANSSlM/rX5hn02BS4DvAE9ExL4ppT+u57z3ANcAR0bElimlD9ZRb1RhPbakdyNJTWS3oKRmkVKaQfb8QYAvlrjPopTSaGACsCnZw1bXt88yYCLQGRherE5EbEb2cNelwF2FsuER8cuI+N+IWBYRiwtdjCeXEmutY6SIWNd5U0Q8XaS8U0T8S0Q8VzjvRxExPSL+NSIa/F2OiKMj4qmI+HtELI+I9yJiakT8S6mxStpwTK4kNacorBs7EPzHhfWREdGjhPq3FtanrmP7yUBX4K6U0tJC2U3AdsDvyFq+7i68viMiLmlkvCWLiM7Ao8ANwGbAnWStaR2A64Cf16t/OvAQ2cOAHwGuIuv+3AgY0VxxSmo6uwUlrRURP/qUzZs18li7AgcUXj7fmH1TSu9ExN+AbYC9gCnrqf9qRLwAfDEiBqWUnq5XpViX4P9JKb1TL+YuwK+BCyLi5pTSu42Ju0Q/AA4Frge+m1JaXTh3x0J8IyPi/pTSQ4X63wZWAJ9PKf2jXry9myE+SWUyuZJU28Vl7PvdiKg9oP1YstaVSSml/27C8d4lS676lFh/LFn34yg+6Y4kIvYGPg9MTylNqymvn1gVylZExA3AQWQD8Sc0Ie51KnT5fQd4H/i3msSqcO7VEXEuWWvUSWStVTVWASuLxDs3z/gk5cPkStJaKaVY17aImEXWbbYuZ9cchmxs02tkY6FubmI4je1SvBv4T2BIRHwnpbSgUH5aYX1r7coR0Q/4PlkS1Y8sEaztM42OeP12AnoBfwbGRBT9di8Ddq71+hdkXYFvRMTdwFTgmZTSnGaIT1IOTK4k5WX7+nf/lWnrwrqkJCKl9GFE3EnWjXYycF1EdAO+CXxIlqQAEBE7AC8APYH/Bp4AFgGrgf7AMKAql3dR1+aF9Wf59FbCTWq+SCldHRFzgX8BRgPfBVJETAXOq90aJ6kyOKBdUsWJiAFkXYKrgJcasWvNmKqaMVbfBLoD96SUFteqdw5ZonNqSmlQSml0SunfU0o/An7TiPOtKawb/KNauEOxvkWF9aSUUnzKsn3tnVJKE1JK+xZiPgIYB+wP/CYiSu02lbSBmFxJqkQ/LKwfSSktKXWnlNLLZMnY7hFRM/4KGs5tNaCw/mWRwxxQpGxdaroety2yrbpI2R/JJk7dt3DXYKOklBamlH6VUjoNGE/Wxbh/Y48jqXmZXEmqGBHRIyKuBb5FloRc0ITD1IytuhLYF3gtpVT/bsVZhfWgeuc/lE8SslJMI2u9OjEiNq51nF7A5fUrp5RWkU230Be4NiLqj/MiIvpGxC61Xh8YxQdnbVFYf9SIeCVtAI65ktRSau4uDD55/M3+QDfgLeDklNJbTTjunWSJ1VcKr28tUudGsrvy7ouI+4H3gP8DHAbcC5xQyolSSn+PiF+QJYOvRMRjhfdyONn8WcWeYXgJ2d2LZwBHRcRvye6M3IJsLNaXyKZreKNQfxKwNCKeI0sKo/De9iZrpZtcSqySNhyTK0ktpebuwlXAErIEYxLZFAQPp5RWNOWgKaUlhbvqRpHdeTexSJ3XIuJA4FKyMUydgFfJpo9YSInJVcFpwAfAUOAsYDZwLXAFcHyRc6+MiMFkg+6HA0eSDWCfA8wE/p1ag+/JWu8OBfYkS9o+Bv5CdqfjTSmlBlM0SGpZkVJjJ06WJEnSujjmSpIkKUcmV5IkSTkyuZIkScqRyZUkSVKOTK4kSZJyZHIlSZKUI5MrSZKkHJlcSZIk5cjkSpIkKUf/H9CD3vxCWbsjAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "fig_hpd = plot_with_uniform_band(values=hpd_values, ci_level=0.99, x_label='HPD Values', n_bins=30) \n", "fig_hpd" diff --git a/vignettes/Custom Class.ipynb b/vignettes/Custom Class.ipynb index 7ace8b8..5dbf65e 100644 --- a/vignettes/Custom Class.ipynb +++ b/vignettes/Custom Class.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -73,34 +73,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'basis_system': 'cosine',\n", - " 'best_basis': range(0, 31),\n", - " 'bump_threshold': None,\n", - " 'max_basis': 31,\n", - " 'model': ,\n", - " 'sharpen_alpha': None,\n", - " 'z_max': array([5.51239725]),\n", - " 'z_min': array([-4.75078052])}" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model.__dict__" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -112,27 +94,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'basis_system': 'cosine',\n", - " 'best_basis': range(0, 31),\n", - " 'bump_threshold': None,\n", - " 'max_basis': 31,\n", - " 'model': ,\n", - " 'sharpen_alpha': None,\n", - " 'z_max': array([5.51239725]),\n", - " 'z_min': array([-4.75078052])}" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model = pickle.load(open('example.pkl', 'rb'))\n", "model.__dict__" @@ -140,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -168,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -193,20 +157,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.max(np.abs(cdes_predict_custom - cdes_predict_xgb))" ] diff --git a/vignettes/Model Save and Bumps Removal - Flexcode.ipynb b/vignettes/Model Save and Bumps Removal - Flexcode.ipynb index 1011c75..ae82054 100644 --- a/vignettes/Model Save and Bumps Removal - Flexcode.ipynb +++ b/vignettes/Model Save and Bumps Removal - Flexcode.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -56,18 +56,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.3204763840926326\n", - "1.315065820028842\n" - ] - } - ], + "outputs": [], "source": [ "# Parameterize model\n", "model = flexcode.FlexCodeModel(XGBoost, max_basis=31, basis_system=\"cosine\",\n", @@ -85,27 +76,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'basis_system': 'cosine',\n", - " 'best_basis': range(0, 31),\n", - " 'bump_threshold': None,\n", - " 'max_basis': 31,\n", - " 'model': ,\n", - " 'sharpen_alpha': None,\n", - " 'z_max': array([4.98535658]),\n", - " 'z_min': array([-4.84002112])}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Print model parameters\n", "model.__dict__" @@ -113,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -126,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -139,18 +112,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.3204763840926326\n", - "1.315065820028842\n" - ] - } - ], + "outputs": [], "source": [ "# Same output as above\n", "print(np.max(cdes_predict_xgb_reloaded[7, :]))\n", @@ -159,27 +123,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'basis_system': 'cosine',\n", - " 'best_basis': range(0, 31),\n", - " 'bump_threshold': None,\n", - " 'max_basis': 31,\n", - " 'model': ,\n", - " 'sharpen_alpha': None,\n", - " 'z_max': array([4.98535658]),\n", - " 'z_min': array([-4.84002112])}" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Print parameters of the reloaded model\n", "model_reloaded.__dict__" @@ -194,18 +140,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 0.11 0.12 0.13 0.14\n", - " 0.15 0.16 0.17 0.18 0.19 0.2 ]\n" - ] - } - ], + "outputs": [], "source": [ "# Define a grid of values to tune over\n", "bump_removal_grid = np.linspace(0.01, 0.2, 20)\n", @@ -214,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -228,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -250,20 +187,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.01" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model.bump_threshold" ]