        <img width="20%" src="https://raw.githubusercontent.com/pysat/pysat/main/docs/images/logo.png" alt="The pysat logo: A snake orbiting a blue sphere" title="pysat"

# pysat: Python Satellite Data Analysis Toolkit
[![PyPI Package latest release](https://img.shields.io/pypi/v/pysat.svg)](https://pypi.python.org/pypi/pysat)
[![Build Status](https://github.com/pysat/pysat/actions/workflows/main.yml/badge.svg)](https://github.com/pysat/pysat/actions/workflows/main.yml/badge.svg)
[![Documentation Status](https://readthedocs.org/projects/pysat/badge/?version=latest)](http://pysat.readthedocs.io/en/latest/?badge=latest)
[![Coverage Status](https://coveralls.io/repos/github/pysat/pysat/badge.svg?branch=main)](https://coveralls.io/github/pysat/pysat?branch=main)
[![DOI](https://zenodo.org/badge/33449914.svg)](https://zenodo.org/badge/latestdoi/33449914)

The Python Satellite Data Analysis Toolkit (pysat) provides a simple and
flexible interface for robust data analysis from beginning to end - including
downloading, loading, cleaning, managing, processing, and analyzing data.
Pysat's plug-in design allows analysis support for any data, including user
provided data sets. The pysat team provides a variety of plug-ins to support
public scientific data sets in packages such as pysatNASA, pysatMadrigal, and
more, available as part of the general [pysat ecosystem](https://github.com/pysat).

Full [Documentation](http://pysat.readthedocs.io/en/latest/index.html)

JGR-Space Physics [Publication](https://doi.org/10.1029/2018JA025297)

Pysat Ecosystem [Publication](https://www.frontiersin.org/articles/10.3389/fspas.2023.1119775/full)

[Citation Info](https://pysat.readthedocs.io/en/latest/citing.html)

Come join us on Slack! An invitation to the pysat workspace is available
in the 'About' section of the
[pysat GitHub Repository.](https://github.com/pysat/pysat)
Development meetings are generally held fortnightly.

# Main Features
* Instrument independent analysis routines.
* Instrument object providing an interface for downloading and analyzing a wide
  variety of science data sets.
  * Uses pandas or xarray for the underlying data structure;
    capable of handling the many forms scientific measurements take in a
    consistent manner.
  * Standard scientific data handling tasks (e.g., identifying, downloading,
    and loading files and cleaning and modifying data) are built into the
    Instrument object.
  * Supports metadata consistent with the netCDF CF-1.6 standard. Each variable
    has a name, long name, and units. Note units are informational only.
* Simplifies data management
  * Iterator support for loading data by day/file/orbit, independent of data
    storage details.
  * Orbits are calculated on the fly from loaded data and span day breaks.
  * Iterate over custom seasons
* Supports rigorous time-series calculations that require spin up/down time
  across day, orbit, and file breaks.
* Includes helper functions to reduce the barrier in adding new science
  instruments to pysat

# Installation

The following instructions provide a guide for installing pysat and give some
examples on how to use the routines.

## Prerequisites

pysat uses common Python modules, as well as modules developed by and for the
Space Physics community.  This module officially supports Python 3.X+.

| Common modules | Community modules |
| -------------- | ----------------- |
| dask           | netCDF4           |
| numpy >= 1.12  |                   |
| pandas         |                   |
| portalocker    |                   |
| pytest         |                   |
| scipy          |                   |
| toolz          |                   |
| xarray         |                   |

## PyPi Installation
```
pip install pysat
```

## GitHub Installation
```
git clone https://github.com/pysat/pysat.git
```

Change directories into the repository folder and run the pyproject.toml or
setup.py file.  For a local install use the "--user" flag after "install".

```
cd pysat/
python -m build .
pip install .
```

# Using pysat

* The first time pysat is run, you will need to specify a directory to store
  the data. In Python, run:
```
pysat.params['data_dirs'] = 'path/to/directory/that/may/or/may/not/exist'
```
  * Nominal organization of data is top_dir/platform/name/tag/inst_id/files

Detailed examples and tutorials for using pysat are available in the
[documentation](http://pysat.readthedocs.io/en/latest/index.html).


[![CI](https://github.com/bluesky/bluesky/actions/workflows/ci.yml/badge.svg)](https://github.com/bluesky/bluesky/actions/workflows/ci.yml)
[![Coverage](https://codecov.io/gh/bluesky/bluesky/branch/main/graph/badge.svg)](https://codecov.io/gh/bluesky/bluesky)
[![PyPI](https://img.shields.io/pypi/v/bluesky.svg)](https://pypi.org/project/bluesky)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

# Bluesky — An Experiment Specification & Orchestration Engine

|    Source     |     <https://github.com/bluesky/bluesky>      |
| :-----------: | :-------------------------------------------: |
|     PyPI      |             `pip install bluesky`             |
| Documentation |      <https://bluesky.github.io/bluesky>      |
|   Releases    | <https://github.com/bluesky/bluesky/releases> |

Bluesky is a library for experiment control and collection of scientific data
and metadata. It emphasizes the following virtues:

* **Live, Streaming Data:** Available for inline visualization and processing.
* **Rich Metadata:** Captured and organized to facilitate reproducibility and
  searchability.
* **Experiment Generality:** Seamlessly reuse a procedure on completely
  different hardware.
* **Interruption Recovery:** Experiments are "rewindable," recovering cleanly
  from interruptions.
* **Automated Suspend/Resume:** Experiments can be run unattended,
  automatically suspending and resuming if needed.
* **Pluggable I/O:** Export data (live) into any desired format or database.
* **Customizability:** Integrate custom experimental procedures and commands,
  and get the I/O and interruption features for free.
* **Integration with Scientific Python:** Interface naturally with numpy and
  Python scientific stack.

[**Bluesky Documentation**](http://blueskyproject.io/bluesky).

The Bluesky Project enables experimental science at the lab-bench or facility scale. It is a collection of Python libraries that are co-developed but independently useful and may be adopted *a la carte*.

[**Bluesky Project Documentation**](http://blueskyproject.io).

<!-- README only content. Anything below this line won't be included in index.md -->

See https://bluesky.github.io/bluesky for more detailed documentation.


# CmdStanPy

[![codecov](https://codecov.io/gh/stan-dev/cmdstanpy/branch/master/graph/badge.svg)](https://codecov.io/gh/stan-dev/cmdstanpy)

CmdStanPy is a lightweight pure-Python interface to CmdStan which provides access to the Stan compiler and all inference algorithms.  It supports both development and production workflows. Because model development and testing may require many iterations, the defaults favor development mode and therefore output files are stored on a temporary filesystem. Non-default options allow all aspects of a run to be specified so that scripts can be used to distributed analysis jobs across nodes and machines.

CmdStanPy is distributed via PyPi: https://pypi.org/project/cmdstanpy/

or Conda Forge: https://anaconda.org/conda-forge/cmdstanpy

### Goals

- Clean interface to Stan services so that CmdStanPy can keep up with Stan releases.

- Provide access to all CmdStan inference methods.

- Easy to install,
  + minimal Python library dependencies: numpy, pandas
  + Python code doesn't interface directly with c++, only calls compiled executables

- Modular - CmdStanPy produces a MCMC sample (or point estimate) from the posterior; other packages do analysis and visualization.

- Low memory overhead - by default, minimal memory used above that required by CmdStanPy; objects run CmdStan programs and track CmdStan input and output files.

### Source Repository

CmdStanPy and CmdStan are available from GitHub: https://github.com/stan-dev/cmdstanpy and https://github.com/stan-dev/cmdstan

### Docs

The latest release documentation is hosted on  https://mc-stan.org/cmdstanpy, older release versions are available from readthedocs:  https://cmdstanpy.readthedocs.io

### Licensing

The CmdStanPy, CmdStan, and the core Stan C++ code are licensed under new BSD.

### Example

```python
import os
from cmdstanpy import cmdstan_path, CmdStanModel

# specify locations of Stan program file and data
stan_file = os.path.join(cmdstan_path(), 'examples', 'bernoulli', 'bernoulli.stan')
data_file = os.path.join(cmdstan_path(), 'examples', 'bernoulli', 'bernoulli.data.json')

# instantiate a model; compiles the Stan program by default
model = CmdStanModel(stan_file=stan_file)

# obtain a posterior sample from the model conditioned on the data
fit = model.sample(chains=4, data=data_file)

# summarize the results (wraps CmdStan `bin/stansummary`):
fit.summary()
```


# user-sync.py: User Sync Tool from Adobe

The User Sync Tool is a command-line tool that automates the creation and management of Adobe user accounts.  It
does this by reading user and group information from an organization's enterprise directory system or a file and
then creating, updating, or removing user accounts in the Adobe Admin Console. The key goals of the User Sync
Tool are to streamline the process of named user deployment and automate user management for all Adobe users and products.

This application is open source, maintained by Adobe, and distributed under the terms
of the OSI-approved MIT license.  See the LICENSE file for details.

Copyright (c) 2016-2022 Adobe Inc.

## Documentation

The [User Sync Documentation](https://adobe-apiplatform.github.io/user-sync.py/) covers all aspects of the tool, from both a general and a technical point of view.  The following links are good places to start:

- [Non-Technical Primer](https://spark.adobe.com/page/E3hSsLq3G1iVz/)
- [User Manual](https://adobe-apiplatform.github.io/user-sync.py/en/user-manual/)
- [Step-by-Step Setup](https://adobe-apiplatform.github.io/user-sync.py/en/success-guide/)

## Technical Requirements

* Windows, Ubuntu or CentOS server/VM (if using a [pre-built release](https://github.com/adobe-apiplatform/user-sync.py/releases/latest))
* At least 4GB of available RAM
* Service account for the User Management API (see the [official docs](https://www.adobe.io/authentication/auth-methods.html#!AdobeDocs/adobeio-auth/master/AuthenticationOverview/ServiceAccountIntegration.md))
* Public/private keys for service account (see the [official docs](https://www.adobe.io/authentication/auth-methods.html#!AdobeDocs/adobeio-auth/master/JWT/JWTCertificate.md))

## Installation and Use

The tool is packaged as a self-contained executable.  See the [latest release page](https://github.com/adobe-apiplatform/user-sync.py/releases/latest)
to get the latest build for your platform. Releases are distributed as archives (`.zip` or `.tar.gz`). Each release file
contains the UST executable.

Full installation instructions can be found [here](https://adobe-apiplatform.github.io/user-sync.py/en/success-guide/install_sync.html).

* On Linux systems, the executable is named `user-sync`.
* On Windows systems, the executable is named `user-sync.exe`.

After downloading and extracting the tool, verify the tool will work on your system:

* `$ ./user-sync --version` (or `> ./user-sync.exe --version`)
* `$ ./user-sync --help` (or `> ./user-sync.exe --help`)

There are a wide variety of command-line arguments; see
[the docs](https://adobe-apiplatform.github.io/user-sync.py/en/user-manual/command_parameters.html) for details.

## Configuration

You will need a personalized User Sync configuration to use the tool effectively.  The documentation includes a [Setup and Success Guide](https://adobe-apiplatform.github.io/user-sync.py/en/success-guide/) that will take you step-by-step through the configuration process.  In addition, the `examples` directory (also available as a tarball on the [releases page](https://github.com/adobe-apiplatform/user-sync.py/releases)) contains sample configuration files which include all of the possible options with their descriptions and default values.

## Build Instructions

The general procedure to build the User Sync Tool is the same across platforms. However, each platform has its own set of
prerequisites that must be met before following these instructions. Refer to the notes for your platform and return here
to learn how to build the Sync Tool from source.

**NOTE:** Python 3.9 is required on all platforms.

1. Clone this repository `git clone https://github.com/adobe-apiplatform/user-sync.py.git`
2. Create a new Python 3.6 virtual environment `python -m venv /path/to/venv` (note: your system may prompt you to install
   additional packages before creating the virtual environment)
3. Activate the environment `source /path/to/venv/bin/activate` (or `.\path\to\venv\Scripts\activate` on Windows)
4. `cd` to the `user-sync.py` directory
5. Install the Okta client wheel `pip install external/okta-0.0.3.1-py2.py3-none-any.whl`
6. Install the Sign client `pip install ./sign_client`
7. Install the sync tool locally
    1. `pip install -e .`
    2. `pip install -e .[test]`
    3. `pip install -e .[setup]`
8. Create the build by running `make`

If the Sync Tool was built successfully, then the executable can be found in the `dist/` directory. The binary will be named
`user-sync` or `user-sync.exe` depending on platform.

### Ubuntu and other Debian variants

**NOTE:** These prerequisites are known to work on Ubuntu 16.04 or newer, but should work on Debian and other Debian variants.

On Linux, many of the Sync Tool's dependencies are built from source and contain components written in C and other compiled
languages. For this reason, it is necessary to install some system packages and libraries.

```bash
sudo apt-get update && \
sudo apt-get install -y \
        software-properties-common build-essential \
        pkg-config libssl-dev libdbus-1-dev \
        libdbus-glib-1-dev python-dbus \
        libffi-dev libkrb5-dev python3.9-dev python3-venv
```

### CentOS and other RedHat variants

**NOTE:** These prerequisites are known to work on CentOS 7 or newer, but should work on Redhat Enterprise Linux and other
Redhat variants.

On Linux, many of the Sync Tool's dependencies are built from source and contain components written in C and other compiled
languages. For this reason, it is necessary to install some system packages and libraries.

```bash
yum groupinstall -y "Development Tools"
yum install -y epel-release
yum install -y https://centos7.iuscommunity.org/ius-release.rpm
yum install -y python36u-devel python36u-pip python36u-virtualenv
yum install -y python-devel python-pip python-virtualenv
yum install -y pkgconfig openssl-devel dbus-glib-devel dbus-python libffi-devel
```

### macOS

On macOS there are a wide variety of ways to get current Python installations that don't interfere with the system-required Python, and a wide way of creating virtual environments for that Python. We strongly recommend using `pyenv` for installation and maintenance and `pyenv-virtualenv` for virtual environment support.  And we recommend getting those via `homebrew`.  The sequence for this is:

1. Install the latest version of the Apple Developer Command Line Tools via `xcode-select --install`.
1. Install Homebrew per the directions [here](http://docs.brew.sh).
1. Install `openssl` via Homebrew: `brew install openssl`
1. Install `pyenv` via Homebrew: `brew install pyenv`
1. Install `pyenv-virtualenv` via Homebrew: `brew install pyenv-virtualenv`
1. Find your desired Python version with: `pyenv install --list`
1. Install that python with `pyenv install ##`, where `##` is the desired version number.
1. Create a virtual environment for your builds, with `pyenv virtualenv ## myname`.
1. In your `user-sync.py` source directory, activate that virtual environment with `pyenv local myname`.

This sequence not only ensures that you are set up to do Python extension compiles, but also that they will know how to find the openssl libraries, and that you can easily install any other needed development libraries with Homebrew.

In general, regardless of how you get your Python, you will need:

* The latest security updates.
* The latest `openssl` (see above).
* The latest version of XCode and/or the Developer Command Line Tools (see above).
* Installs of modern openssl, ffi, and pkg-config libraries.  With Homebrew, you can do:
    ```bash
    homebrew install pkg-config openssl libffi
    ```
* To know how to include the XCode `include` directory in a compile spawned from `pip` install.  If you didn't do a command line developer tools install (which puts the headers into /usr/include), you can do:
    * `CFLAGS="-I$(xcrun --show-sdk-path) pip install ...`.
* To know how to include a modern `openssl` header path in a `pip` install.  If you installed your Python via Homebrew or `pyenv`, this is taken care of for you, see above.  Otherwise, if you installed ssl with Homebrew, you can do:`CFLAGS="-I$(brew --prefix openssl)/include"  LDFLAGS="-L$(brew --prefix openssl)/lib" pip install ...`.

### Windows

**NOTE:** We recommend installing a Git client build that can be run from Windows Powershell or `cmd.exe`. [Scoop](https://scoop.sh)
provides a package to easily install Git natively. Build instructions are not guaranteed to work in Git Bash.

* Python 3.6 (see python.org for latest 3.6 release)
* [Chocolatey](https://chocolatey.org/)
* [Scoop](https://scoop.sh) (if you need to install Git)
* GNU Make (install with Chocolatey - `choco install make`)
* Git (if not installed) - `scoop install git`

If you already have some other version of Python installed, you will want to use the `py` tool to create the virtual environment.

```
> py -3.6 -m venv \path\to\venv
```

This ensures that the virtual environment is linked to the correct version of Python.

Once all Windows prerequisites are met, refer to the generic build instructions above to complete the build.


<picture>
  <source
    srcset="https://raw.githubusercontent.com/CNES/cars/master/docs/source/images/picto_dark.png"
    media="(prefers-color-scheme: dark)"
  />

</picture>

CARS, a satellite multi view stereo framework

[![Python](https://img.shields.io/badge/python-v3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
[![Contributions welcome](https://img.shields.io/badge/contributions-welcome-orange.svg)](CONTRIBUTING.md)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0/)
[![Documentation](https://readthedocs.org/projects/cars/badge/?version=latest)](https://cars.readthedocs.io/?badge=latest)

  Overview •
  Quick Start •
  Documentation •
  Contribution •
  References

## Overview

From stereo images  |  CARS produces a Digital Surface Model (DSM)
:-------------------------:|:-------------------------:
 |

**CARS** is an open source 3D tool dedicated to produce **Digital Surface Models** from satellite imaging by photogrammetry.
This Multiview Stereo framework is intended for massive DSM production with a robust, performant and modular design.

Be aware that the project is new and is evolving to maturity with CNES usage roadmaps and projects such as:
- CO3D project
- AI4GEO project
- Evoland project

## Quick start

### CARS Docker Image

[![Docker Status](http://dockeri.co/image/cnes/cars)](https://hub.docker.com/r/cnes/cars)

CARS is available on Docker Hub and can be downloaded by:
``` bash
docker pull cnes/cars
```

### One main pipeline to generate DSM

You only need to launch one command:

```
docker run -w /data -v "$(pwd)"/data_gizeh:/data cnes/cars /data/configfile.json
```

with one configuration input file ("configfile.json") located in a "data" folder to be consistent with the previous command lines:
```
{

        "inputs": {
            "sensors" : {
                "one": {
                    "image": "img1.tif",
                    "geomodel": "img1.geom"
                },
                "two": {
                    "image": "img2.tif",
                    "geomodel": "img2.geom"
                },
                "three": {
                    "image": "img3.tif",
                    "geomodel": "img3.geom"
                }
            },
            "pairing": [["one", "two"],["one", "three"]],
            "initial_elevation": "srtm_dir/N29E031_KHEOPS.tif"
        },

        "output": {
              "out_dir": "outresults"
        }

}

```

### On the way to the Pyramids...

You want to build the pyramids by yourself? Download our [open licence](https://www.etalab.gouv.fr/licence-ouverte-open-licence) Pleiades [data sample](https://raw.githubusercontent.com/CNES/cars/master/tutorials/data_gizeh.tar.bz2) to give CARS a try!

## Documentation

Go to [CARS Main Documentation](https://cars.readthedocs.io/?badge=latest).

## Contribution

To do a bug report or a contribution, see the [**Contribution Guide**](https://github.com/CNES/cars/blob/master/CONTRIBUTING.md).

For project evolution, see [**Changelog**](https://github.com/CNES/cars/blob/master/CHANGELOG.md).

## Credits

See [Authors file](https://github.com/CNES/cars/blob/master/AUTHORS.md)

## References

- [Youssefi D., Michel, J., Sarrazin, E., Buffe, F., Cournet, M., Delvit, J., L’Helguen, C., Melet, O., Emilien, A., Bosman, J., 2020. Cars: A photogrammetry pipeline using dask graphs to construct a global 3d model. IGARSS - IEEE International Geoscience and Remote Sensing Symposium.](https://ieeexplore.ieee.org/document/9324020)
- [Michel, J., Sarrazin, E., Youssefi, D., Cournet, M., Buffe, F., Delvit, J., Emilien, A., Bosman, J., Melet, O., L’Helguen, C., 2020. A new satellite imagery stereo pipeline designed for scalability, robustness and performance. ISPRS - International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences.](https://www.isprs-ann-photogramm-remote-sens-spatial-inf-sci.net/V-2-2020/171/2020/)


![logo](docs/images_wiki/bifacial_radiance.png)

# bifacial_radiance
Main branch: [![Build Status](https://github.com/nrel/bifacial_radiance/actions/workflows/pytest.yaml/badge.svg?branch=main)](https://github.com/nrel/bifacial_radiance/actions)
[![Coverage Status](https://coveralls.io/repos/github/NREL/bifacial_radiance/badge.svg?branch=main)](https://coveralls.io/github/NREL/bifacial_radiance?branch=main)
[![Documentation Status](https://readthedocs.org/projects/bifacial-radiance/badge/?version=stable)](https://bifacial-radiance.readthedocs.io/en/latest/?badge=stable)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3860350.svg)](https://doi.org/10.5281/zenodo.3860350)
[![status](https://joss.theoj.org/papers/b018890e2ab7ddf723d37b17e308e273/status.svg)](https://joss.theoj.org/papers/b018890e2ab7ddf723d37b17e308e273)

Development branch: [![Build Status](https://github.com/nrel/bifacial_radiance/actions/workflows/pytest.yaml/badge.svg?branch=development)](https://github.com/nrel/bifacial_radiance/actions)
[![Coverage Status](https://coveralls.io/repos/github/NREL/bifacial_radiance/badge.svg?branch=development)](https://coveralls.io/github/NREL/bifacial_radiance?branch=development)
[![Documentation Status](https://readthedocs.org/projects/bifacial-radiance/badge/?version=latest)](https://bifacial-radiance.readthedocs.io/en/latest/?badge=latest)

## Introduction

bifacial_radiance contains a series of Python wrapper functions to make working with
RADIANCE easier, particularly for the PV researcher interested in bifacial PV
performance.  For more information, check out our [documentation](https://bifacial-radiance.readthedocs.io),
[Tutorials in the form of Jupyter Notebooks](docs/tutorials/), or reffer to our [Wiki](https://github.com/NREL/bifacial_radiance/wiki)
and [Issues](https://github.com/NREL/bifacial_radiance/issues) page.

## Installation

https://youtu.be/4A9GocfHKyM
This video shows how to install the bifacial_radiance software and all associated software needed. More info on the Wiki. Instructions are also shown below.

For detailed instructions of how to install bifacial_radiance, you can also refer to the [installation guide](https://bifacial-radiance.readthedocs.io/en/stable/installation.html)

## GUI!

A GUI has been added in version 3.0. The GUI reads/writes all input parameters necessary to run a simulation, and runs the specified simulation by calling the correct functions with the specified parameters. So no need to use a journal or a script! But you still need to install following the procedure below.

To run the gui, import bifacial_radiance and run bifacial_radiance.gui()

![GUI](docs/images_wiki/bifacial_radiance_GUI.png)

## Usage

We have a tutorial video, showing how the program is structured, how to use the Jupyter tutorials and the GUI. You can watch it here [Tutorial Webinar](https://www.youtube.com/watch?v=1X9L-R-RVGA), with the [slides available here](https://www.nrel.gov/docs/fy20osti/75218.pdf).

Check out the [Jupyter Tutorial Notebooks](docs/tutorials/) to see detailed examples of the capacities of bifacial_radiance.
The [Intro examples](https://bifacial-radiance.readthedocs.io/en/stable/introexamples.html) and the [readthedocs documentation](https://bifacial-radiance.readthedocs.io) also provide a good starting point.

## Contributing

We need your help to make bifacial_radiance a great tool! Please see the [Contributing page](https://bifacial-radiance.readthedocs.io/en/stable/contributing.html) for more on how you can contribute. The long-term success of bifacial_radiance requires substantial community support.

## License

Bifacial_radiance open source code is copyrighted by the Alliance for Sustainable Energy and licensed with BSD-3-Clause terms, found [here](https://github.com/NREL/bifacial_radiance/blob/master/LICENSE).

## Getting Support

If you suspect that you may have discovered a bug or if you'd like to
change something about bifacial_radiance, then please make an issue on our
[GitHub issues page](https://github.com/NREL/bifacial_radiance/issues).

bifacial_radiance questions can be asked on
[Stack Overflow](http://stackoverflow.com) and tagged with
the [bifacial_radiance](http://stackoverflow.com/questions/tagged/bifacial_radiance) tag.

The [bifacial-radiance google group](https://groups.google.com/forum/#!forum/bifacial_radiance)
has just started, and will be used for discussing various topics of interest to the bifacial-radiance
community. We also make new version announcements on the google group.

## Citing

If you use bifacial_radiance in a published work, please cite:

    Ayala Pelaez and Deline, (2020). bifacial_radiance: a python package for modeling bifacial solar photovoltaic systems. Journal of Open Source Software, 5(50), 1865, https://doi.org/10.21105/joss.01865

Please also cite the DOI corresponding to the specific version of bifacial_radiance that you used. bifacial_radiance DOIs are listed at [Zenodo.org](https://zenodo.org/search?page=1&size=20&q=conceptrecid:3860349&all_versions&sort=-version)

Additional bifacial_radiance publications with validation of the software include:
* Deline, Chris, and Ayala, Silvana. Bifacial_Radiance. Computer Software. https://github.com/NREL/bifacial_radiance. USDOE Office of     Energy Efficiency and Renewable Energy (EERE), Solar Energy Technologies Office (EE-4S). 17 Dec. 2017. Web. doi:10.11578/dc.20180530.16. https://www.osti.gov/doecode/biblio/6869
* Ayala Pelaez S, Deline C, Greenberg P, Stein JS, Kostuk RK. Model and validation of single-axis tracking with bifacial PV. IEEE J Photovoltaics. 2019;9(3):715-721. https://ieeexplore.ieee.org/document/8644027 and https://www.nrel.gov/docs/fy19osti/72039.pdf (pre-print, conference version)
* Ayala Pelaez, Deline C, MacAlpine M, Marion B, Stein J, Kostuk K. Comparison of Bifacial Solar Irradiance Model Predictions with Field Validation. IEEE J Photovoltaics. 2019; 9(1):82-87. https://ieeexplore.ieee.org/document/8534404

Or check our [Github Wiki](https://github.com/NREL/bifacial_radiance/wiki) for a complete list of publications.


# `ixmp`: the ix modeling platform

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4005665.svg)](https://doi.org/10.5281/zenodo.4005665)
[![PyPI version](https://img.shields.io/pypi/v/ixmp.svg)](https://pypi.python.org/pypi/ixmp/)
[![Anaconda version](https://img.shields.io/conda/vn/conda-forge/ixmp)](https://anaconda.org/conda-forge/ixmp)
[![Documentation build](https://readthedocs.com/projects/iiasa-energy-program-ixmp/badge/?version=latest)](https://docs.messageix.org/projects/ixmp/en/latest/)
[![Build status](https://github.com/iiasa/ixmp/actions/workflows/pytest.yaml/badge.svg)](https://github.com/iiasa/ixmp/actions/workflows/pytest.yaml)
[![Test coverage](https://codecov.io/gh/iiasa/ixmp/branch/master/graph/badge.svg)](https://codecov.io/gh/iiasa/ixmp)

The ix modeling platform (`ixmp`) is a data warehouse for high-powered scenario
analysis, with interfaces to Python and R for efficient scientific workflows and
effective data pre- and post-processing, and a structured database backend for
version-controlled data management.
In the name, “ix” stands for “integrated” and “cross (x) cutting”.

The [MESSAGEix modeling *framework*](https://docs.messageix.org) is built on top of the ix modeling *platform*.

This repository contains the core and application programming interfaces (API)
for the ix modeling platform (ixmp), as well as a number of tutorials and
examples for a generic model instance based on Dantzig's transport problem.

## Documentation

Complete documentation of the ixmp API is available for current and past versions at: https://docs.messageix.org/ixmp/.
This includes:

- **Installation.**
  Most users will have ixmp installed automatically as a dependency when
[installing MESSAGEix](https://docs.messageix.org/en/stable/#getting-started).
  To install ixmp from source code, or to use ixmp from R, see
[‘Installation’](https://docs.messageix.org/projects/ixmp/en/stable/install.html) or [`INSTALL.rst`](INSTALL.rst).
- **Tutorials.** Introductory tutorials are provided in both Python and R; see [‘Tutorials’](https://docs.messageix.org/projects/ixmp/en/stable/tutorials.html) or [`tutorial/README.rst`](tutorial/README.rst).
- How to **cite `ixmp` when using it in published scientific work.** See [‘User guidelines and notice’](https://docs.messageix.org/en/stable/notice.html) or [`NOTICE.rst`](NOTICE.rst).
- **Changelog and migration notes** for each new release: see [“What's New”](https://docs.messageix.org/projects/ixmp/en/stable/whatsnew.html).

Other forms of documentation:

- The online documentation is built automatically from the contents of the
[ixmp GitHub repository](https://github.com/iiasa/ixmp).
- For documentation of a specific release, e.g. `v3.2.0`, use the chooser in the bottom sidebar.
- For offline use, the documentation can be built from the source code.
See [`doc/README.rst`](doc/README.rst) for further details.
- The [MESSAGEix API documentation](https://docs.messageix.org/en/stable/api.html) links to the ixmp documentation in many places, for convenience.

## License

Copyright © 2017–2024 IIASA Energy, Climate, and Environment (ECE) program

`ixmp` is licensed under the Apache License, Version 2.0 (the "License"); you
may not use the files in this repository except in compliance with the License.
You may obtain a copy of the License in [`LICENSE`](LICENSE) or at
<https://www.apache.org/licenses/LICENSE-2.0>.


**********
Databroker
**********

|build_status| |coverage| |pypi_version| |license|

Databroker is a data **access** tool built around the `Bluesky Data Model`_.
The data it manages may be from ingested files, captured results of a
Python-based data analysis, or experimental data acquired using the Bluesky Run
Engine.

* Provide a consistent programmatic interface to data, **regardless of storage
  details** like file format or storage medium.
* Provide **metadata and data** in a coherent bundle, using standard widely-used
  Python and SciPy data structures.
* Support fast, flexible **search** over metadata.
* Enable software tools to operate seamlessly on a
  mixture of **live-streaming** data from the Bluesky Run Engine and **saved**
  data from Databroker.

Databroker is developed in concert with `Suitcase`_. Suitcase does data
*writing*, and databroker does the reading. Databroker builds on `Intake`_, a
generic data access tool (outside of the Bluesky Project).

============== ==============================================================
PyPI           ``pip install databroker``
Conda          ``conda install -c conda-forge databroker``
Source code    https://github.com/bluesky/databroker
Documentation  https://blueskyproject.io/databroker
============== ==============================================================

The bundle of metadata and data looks like this, for example.

.. code:: python

   >>> run
   BlueskyRun
     uid='4a794c63-8223-4893-895e-d16e763188a8'
     exit_status='success'
     2020-03-07 09:17:40.436 -- 2020-03-07 09:28:53.173
     Streams:
       * primary
       * baseline

Additional user metadata beyond what is shown is stored in ``run.metadata``.
The bundle contains some number of logical tables of data ("streams"). They can
be accessed by name and read into a standard data structure from `xarray`_.

.. code:: python

    >>> run.primary.read()
    <xarray.Dataset>
    Dimensions:                   (time: 411)
    Coordinates:
      * time                      (time) float64 1.584e+09 1.584e+09 ... 1.584e+09
    Data variables:
        I0                        (time) float64 13.07 13.01 12.95 ... 9.862 9.845
        It                        (time) float64 11.52 11.47 11.44 ... 4.971 4.968
        Ir                        (time) float64 10.96 10.92 10.88 ... 4.761 4.763
        dwti_dwell_time           (time) float64 1.0 1.0 1.0 1.0 ... 1.0 1.0 1.0 1.0
        dwti_dwell_time_setpoint  (time) float64 1.0 1.0 1.0 1.0 ... 1.0 1.0 1.0 1.0
        dcm_energy                (time) float64 1.697e+04 1.698e+04 ... 1.791e+04
        dcm_energy_setpoint       (time) float64 1.697e+04 1.698e+04 ... 1.791e+04

Common search queries can be done with a high-level Python interface.

.. code:: python

    >>> from databroker.queries import TimeRange
    >>> catalog.search(TimeRange(since="2020"))

Custom queries can be done with the `MongoDB query language`_.

.. code:: python

    >>> query = {
    ...    "motors": {"$in": ["x", "y"]},  # scanning either x or y
    ...    "temperature" {"$lt": 300},  # temperature less than 300
    ...    "sample.element": "Ni",
    ... }
    >>> catalog.search(query)

See the tutorials for more.

.. |build_status| image:: https://github.com/bluesky/databroker/workflows/Unit%20Tests/badge.svg?branch=master
    :target: https://github.com/bluesky/databroker/actions?query=workflow%3A%22Unit+Tests%22
    :alt: Build Status

.. |coverage| image:: https://codecov.io/gh/bluesky/databroker/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/bluesky/databroker
    :alt: Test Coverage

.. |pypi_version| image:: https://img.shields.io/pypi/v/databroker.svg
    :target: https://pypi.org/project/databroker
    :alt: Latest PyPI version

.. |license| image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
    :target: https://opensource.org/licenses/BSD-3-Clause
    :alt: BSD 3-Clause License

.. _xarray: https://xarray.pydata.org/

.. _MongoDB query language: https://docs.mongodb.com/manual/reference/operator/query/

.. _Bluesky Data Model: https://blueskyproject.io/event-model/main/user/explanations/data-model.html

.. _Suitcase: https://blueskyproject.io/suitcase/

.. _Intake: https://intake.readthedocs.io/en/latest/


# pyuvsim

![](https://github.com/RadioAstronomySoftwareGroup/pyuvsim/workflows/Tests/badge.svg?branch=main)
[![codecov](https://codecov.io/gh/RadioAstronomySoftwareGroup/pyuvsim/branch/main/graph/badge.svg)](https://codecov.io/gh/RadioAstronomySoftwareGroup/pyuvsim)

pyuvsim is a comprehensive simulation package for radio interferometers in python.

A number of analysis tools are available to simulate the output of a radio
interferometer (CASA, OSKAR, FHD, PRISim, et al), however each makes numerical
approximations to enable speed ups. pyuvsim's goal is to provide a simulated
instrument output which emphasizes accuracy and extensibility, and can represent the most
general simulator design.

A comparison to other simulators may be found [here](https://pyuvsim.readthedocs.io/en/latest/comparison.html).

## pyuvsim, the Interferometer Simulator of Record
pyuvsim's  primary goal is to be an interferometer simulator accurate at the level of
precision necessary for 21cm cosmology science,

1. High level of test coverage including accuracy (design goal is 97%).
2. Testing against analytic calculations, monitored by continuous integration (see memo #XXX)
3. Comparison with external simulations with standardized reference simulations

## Usability and extensibility
A secondary goal is a community simulation environment which provides well documented and flexible code to support a diversity of use cases.
Key elements of this approach include:
1. Design for scalability across many cpus.
2. Defining a clear, user-friendly standard for simulation design.
3. Documentation of analytic validation and reference simulations

# Physical Instrumental Effects
Each addition of new physics is validated against analytic calculations and included in a new reference simulation. Physics that have been included or are on the roadmap.
1. Fully-polarized instrument response (complete)
1. Polarized sources (analytic testing ~90% )
1. Floating-point source position accuracy (complete)
1. Full-sky field of view (complete)
1. Exact antenna positions.  (complete)
1. Varied beam models across the array (complete, tested against analytic)
1. Diffuse emission (complete, tested against analytic, paper in prep)
1. Arbitrary spectrum (complete)
1. Non-terrestrial observatories (Lunar observatory complete)
1. Time domain sources (TODO)
1. Ionospheric scintillation (TODO)

# Citation
Please cite pyuvsim by citing our JOSS paper:

Lanman et al., (2019). pyuvsim: A comprehensive simulation package for radio
interferometers in python. Journal of Open Source Software, 4(37), 1234,
https://doi.org/10.21105/joss.01234

[ADS Link](https://ui.adsabs.harvard.edu/abs/2019JOSS....4.1234L/abstract)

## Installation
Simple installation via pip is available for users, developers should follow
the directions under [Developer Installation](#developer-installation) below.

A user-installation is achieved simply with `pip install pyuvsim`, or to get the
bleeding-edge: `pip install https://github.com/RadioAstronomySoftwareGroup/pyuvsim`.

By default, `mpi` capabilities are not enabled -- many of the utilities provided
in `pyuvsim` do not require it. To use the simulator within `pyuvsim`, you
should install `pyuvsim` with  `pip install pyuvsim[sim]`. Note that the
`pyuvsim` simulator is intended to run on clusters running the linux operating
system, but we test against Mac OSX as well. We test against both Open MPI and MPICH.

There are a few more optional dependencies for `pyuvsim` which enable some features,
such as `astropy_healpix` to use healpix based sky catalogs or healpix beams,
`python-casacore` for writing out measurement sets and `lunarsky` for simulating telescopes
on the moon. If you would like these tools as well as the full simulator, install
`pyuvsim` with `pip install pyuvsim[all]` (or use the `[healpix]`, `[casa]` or `[moon]`
options to only get the dependencies for each of those functionalities).

If you wish to manage dependencies manually read on.

### Dependencies
If you are using `conda` to manage your environment, you may wish to install the
following packages before installing `pyuvsim`:

Required:

* astropy>=6.0
* numpy>=1.23
* psutil
* pyradiosky>=0.2.0
* python>=3.10
* pyuvdata>=2.4.3
* pyyaml>=5.4.1
* scipy>=1.7.3
* setuptools_scm>=7.0.3

Optional:

* astropy-healpix>=1.0.2 (for using healpix based sky catalogs or beams)
* mpi4py>=3.1.1 (for actually running simulations)
* lunarsky>=0.2.2 (for simulating telescopes on the moon)
* python-casacore>=3.5.2 (for writing CASA measurement sets)

### Developer Installation
If you are developing `pyuvsim`, you will need to download and install the
repository using `git clone https://github.com/RadioAstronomySoftwareGroup/pyuvsim.git`.

Navigate into the pyuvsim directory and run `pip install .` or `pip install -e .`
for a developer install (which makes it so that you don't have to reinstall
every time you change the code)
Note that this will attempt to automatically install any missing dependencies.
If you use anaconda or another package manager you might prefer to first install
the dependencies as described in [Dependencies](#dependencies) (as well as the
developer dependencies listed below).

To install without dependencies, run `pip install --no-deps .`
(optionally with the `-e` flag as well).

If you want to do development on pyuvsim, in addition to the other dependencies
you will need the following packages:

* coverage
* line-profiler
* pre-commit
* pytest
* pytest-cov >= 5.0
* pypandoc
* sphinx

One other package, pytest-xdist, is not required, but can be used to speed up running
the test suite by running tests in parallel. To use it call pytest with the
```-n auto``` option.

One way to ensure you have all the needed packages is to use the included
`environment.yaml` file to create a new environment that will
contain all the optional dependencies along with dependencies required for
testing and development (```conda env create -f environment.yaml```).
Alternatively, you can specify `test`, `doc`, or `dev` when installing pyuvdata
(as in `pip install .[dev]`) to install the packages needed for testing
(including coverage and linting) and documentation development;
`dev` includes everything in `test` and `doc`.

Finally, install the pre-commit hook using `pre-commit install` to help prevent
committing code that does not meet our style guidelines.

## Inputs

A simulation requires sets of times, frequencies, source positions and brightnesses, antenna positions, and direction-dependent primary beam responses. pyuvsim specifies times, frequencies, and array configuration via a UVData object (from the pyuvdata package), source positions and brightnesses via Source objects, and primary beams either through UVBeam or AnalyticBeam objects.

* All sources are treated as point sources, with flux specified in Stokes parameters and position in right ascension / declination in the International Celestial Reference Frame (equivalently, in J2000 epoch).
* Primary beams are specified as full electric field components, and are interpolated in angle and frequency. This allows for an exact Jones matrix to be constructed for each desired source position.
* Multiple beam models may be used throughout the array, allowing for more complex instrument responses to be modeled.

These input objects may be made from a data file or from a set of `yaml` configuration files. See [Running a simulation](https://pyuvsim.readthedocs.io/en/latest/usage.html).

## Outputs

Data from a simulation run are written out to a file in any format accessible with `pyuvdata`. This includes:

* uvfits
* MIRIAD
* uvh5

When read into a UVData object, the `history` string will contain information on the pyuvsim and pyuvdata versions used for that run (including the latest git hash, if available), and details on the catalog used.

## Quick start guide
Example `obsparam` configuration files may be found in the `reference_simulations` directory.

1. Install from github or pip.
2. Run off of a parameter file with 4 MPI ranks:
```
mpirun -n 4 python scripts/run_param_pyuvsim.py reference_simulations/first_generation/obsparam_ref_1.1.yaml
```

## Documentation
Documentation on how to run simulations and developer API documentation is hosted on [ReadTheDocs](https://pyuvsim.readthedocs.io).

## Testing

`pyuvsim` uses the `pytest` package for unit testing. If you've cloned the source into a directory `pyuvsim/`, you may verify it as follows:

1. Install `pytest` from anaconda or pip.
2. Run the pytest from `pyuvsim/`
```
pytest
```
You can alternatively run `python -m pytest pyuvsim` or `python setup.py test`.
You will need to have all dependencies installed.

Some tests are run in parallel using the mpi4py module. Those tests have a decorator
`pytest.mark.parallel(n)` where `n` is an integer giving the number
of parallel processes to run the test on. To temporarily disable parallel tests,
run pytest with the option `--nompi`.

## Where to find Support

Please feel free to submit new issues to the [issue log](https://github.com/RadioAstronomySoftwareGroup/pyuvsim/issues) to request new features, document new bugs, or ask questions.

## How to contribute
Contributions to this package to add new features or address any of the
issues in the [issue log](https://github.com/RadioAstronomySoftwareGroup/pyuvsim/issues) are very welcome, as are bug reports or feature requests.
Please see our [guide on contributing](.github/CONTRIBUTING.md)

## Versioning Approach
We use a `generation.major.minor` format.

* Generation - Release combining multiple new physical effects and or major computational improvements.
Testing: Backed by unittests, internal model validation, and significant external comparison.
* Major - Adds new physical effect or major computational improvement. Small number of improvements with each release.
Testing: Backed by unittests, internal model validation and limited external comparison.
* Minor - Bug fixes and small improvements not expected to change physical model
and which do not include breaking API changes.
Testing: Backed by unittests

We do our best to provide a significant period (usually 2 major generations) of
deprecation warnings for all breaking changes to the API.
We track all changes in our [changelog](https://github.com/RadioAstronomySoftwareGroup/pyuvsim/blob/main/CHANGELOG.md).

### Some helpful definitions
* __Physical effects__: things like polarization effects, noise, ionospheric modeling, or nonterrestrial observing positions.
* __Major computational improvement__:  Support for new catalog types (e.g, diffuse maps), new analysis tools, changes to parallelization scheme
* __Small improvements__: Better documentation or example code, outer framework redesign.

# Maintainers
pyuvsim is maintained by the RASG Managers, which currently include:

 - Adam Beardsley (Arizona State University)
 - Bryna Hazelton (University of Washington)
 - Daniel Jacobs (Arizona State University)
 - Paul La Plante (University of California, Berkeley)
 - Jonathan Pober (Brown University)

Please use the channels discussed in the [guide on contributing](.github/CONTRIBUTING.md)
for code-related discussions. You can contact us privately if needed at
[rasgmanagers@gmail.com](mailto:rasgmanagers@gmail.com).


# OpenPulse: Open Source Software for Pulsation Analysis of Pipeline Systems

*v2.0 April 30th 2024 (now: v2.0.0a5 May 28th 2024)*

OpenPulse is a software written in Python for numerical modelling of low-frequency acoustically induced vibration in gas pipeline systems. It allows to create or/and import the geometry of the pipe system, insert materials properties, set standardized or customized sections, and import pressure/acceleration/force loads (from measurements or theory). OpenPulse performs an acoustic time-harmonic response analysis of the respective 1D acoustic domain using the Finite Element Transfer Matrix Method (FETM). The resulting pressure field is applied as a distributed load over the respective structural piping system, modeled with the Timoshenko beam theory and the Finite Element Method (FEM), in order to run a structural time-harmonic response analysis. In addition to simply boundary conditions as constraints on displacements, OpenPulse allows to insert lumped springs, masses and dampers along the domain.

After defining the FEM mesh for the model, you can plot the piping system geometry and run simulations such as modal analysis and harmonic analysis. It is possible to plot deformed shapes, frequency plots of acoustical and structural responses, stress fields and local stresses of desired sections.

*What's new?*

- New geometry interface: now the user can draw geometry through an intuitive interface, following the conventions of popular piping software.
- Standardization of sections and materials, along with using various unit systems.
- Adjustments and validation of the reciprocating compressor model.
- Physics validation of several analysis after comparing with 3D FEM commercial softwares.
- New interface and visualization tools.
- Enhancements of project files management.
- Enhanced animation of results (real and imaginary parts, phase monitoring, etc).

## New geometry interface

## Enhanced FE/FETM modeling and representation

## Dark theme

## Enhanced results visualisation

## Installing through an executable

- Install OpenPulse for Windows and Linux downloading the executables [here](https://github.com/open-pulse/OpenPulse/releases).

## Installing through your Python IDE

- **Install Python 3.9.0 or later** ([download](https://www.python.org/downloads/release/python-390/)).

- **Install OpenPulse**.
Clone or download [OpenPulse](https://github.com/open-pulse/OpenPulse) files. In the case of download, unzip the received file and open a terminal in the main folder (preferably, **use PowerShell as administrator**). Start by installing the
poetry module using the command:
```
pip install poetry
```

then enter the following command to install all dependencies:

```
poetry install
```

Note: if some warning was logged repeat the command 'poetry install' before trying to run OpenPulse.

- **Run OpenPulse**.
In the same folder, enter the following command in the terminal:
```
poetry run python pulse
```

## Documentation
- You can read the API reference [here](https://open-pulse.readthedocs.io/en/latest/index.html).

- Theory Reference for [1D Acoustics](https://open-pulse.github.io/OpenPulse/doc/Acoustics.pdf), [Structural Vibration of Timoshenko Beams using FEM](https://open-pulse.github.io/OpenPulse/doc/Theory_Structural.pdf), [Weak Fluid-Structure-Coupling FETM-FEM](https://github.com/open-pulse/OpenPulse/blob/master/doc/OpenPulse___Report_D___Weak_Coupling.pdf), [Solution Types (May, 15th 21)](https://), [Matrix Assembly Technique using Python](https://open-pulse.github.io/OpenPulse/doc/Assembly.pdf) and [Stress Stiffening (Prestress)](https://github.com/open-pulse/OpenPulse/blob/master/doc/OpenPulse___Report_E___Prestress.pdf).

- Project page on [Researchgate](https://www.researchgate.net/project/Acoustically-Induced-Vibration-in-Pipeline-Systems).

- [Português] Demonstração rápida: [MOPT YouTube](https://youtu.be/-C5Am9ekM7E).

## Article published: Mechanical Systems and Signal Processing - Volume 186, 1 March 2023

- [Time-harmonic analysis of acoustic pulsation in gas pipeline systems using the Finite Element Transfer Matrix Method: Theoretical aspects](https://doi.org/10.1016/j.ymssp.2022.109824).

## ISMA2020 - International Conference on Noise and Vibration Engineering

- [Presentation](https://www.youtube.com/watch?v=iarKDAei6fg&t).
- [Full Paper](https://github.com/open-pulse/OpenPulse/blob/master/doc/ISMA_2020_PRE.pdf).

## ASA Meeting 2020 - The 179th Meeting of the Acoustical Society of America

- [Effect of flow on the acoustic length correction factor of a Helmholtz resonator neck at high Strouhal number: a symmetric three-dimensional parametric study](https://asa.scitation.org/doi/10.1121/1.5147459).

## FIA 2020/22 - 12o Congresso Iberoamericano de Acústica

- [FIA2020/2022](https://fia2020.com.br/anais/index.php#topo).

## EEA Forum Acusticum 2023 - 10th Convention of the European Acoustics Association

- [Vargas \& Silva, 2023](https://appfa2023.silsystem.solutions/).

## Next events

- Internoise 2024, 25 - 29 August, Nantes, France.
- IIR conference on Compressors and Refrigerants 2024, 9 - 11 September, Bratislava, Slovakia.

## Questions
If you have any questions you can open a new issue with the tag 'question'.

## Authors

The authors are members of MOPT - Multidisciplinary Optimization Group, from Federal University of Santa Catarina (Florianópolis, SC, Brazil).

   - [Olavo M. Silva](https://www.linkedin.com/in/olavo-m-silva-5822a5151/) - Engineer;
   - [Jacson G. Vargas](https://www.linkedin.com/in/jacson-gil-vargas-a54b0768/) - Engineer;
   - [Andre F. Fernandes](https://www.linkedin.com/in/andrefpf/) - Computer Scientist;
   - [Rodrigo Schwartz](https://www.linkedin.com/in/rodrigo-schwartz-249308244/) - Computer Scientist;
   - [Diego M. Tuozzo](https://www.linkedin.com/in/martintuozzo/) - Engineer (Former Member);
   - [Lucas V. Q. Kulakauskas](https://www.linkedin.com/in/lucas-kulakauskas-5a0314182/) - Engineer (Former Member);
   - [Ana P. Rocha](https://www.linkedin.com/in/ana-paula-da-rocha-55520a176/) - Engineer (Former Member);
   - [José L. Souza](https://www.linkedin.com/in/jos%C3%A9-luiz-de-souza-8669b5114/) - Computer Scientist (Former Member);
   - [Danilo Espindola](https://www.linkedin.com/in/danilo-espindola-7b47a626b/) - Interface with other softwares;
   - [Vitor Slongo](https://www.linkedin.com/in/vitor-slongo-45298a270/) - Mesh and Geometry Specialist;
   - [Gildean Almeida](https://www.linkedin.com/in/gildean-almeida-708862298/) - Validation;
   - [Fabrício Cruz](https://www.linkedin.com/in/fabricio-emanuel-cruz/) - Validation.

![alt text](https://open-pulse.github.io/OpenPulse/doc/MOPT.JPG?raw=true)

**


wee-slack
=========

A WeeChat native client for Slack.com. Provides supplemental features only available in the web/mobile clients such as: synchronizing read markers, typing notification, threads (and more)! Connects via the Slack API, and maintains a persistent websocket for notification of events.

![animated screenshot](https://github.com/wee-slack/wee-slack/raw/master/docs/slack.gif)

Table of Contents
-----------------
  * [Features](#features)
  * [Contributing](#contributing)
  * [Dependencies](#dependencies)
  * [Setup](#setup)
     * [1. Install dependencies](#1-install-dependencies)
     * [2. Install and load wee-slack](#2-install-and-load-wee-slack)
        * [From the WeeChat script repo](#from-the-weechat-script-repo)
        * [From the GitHub repo](#from-the-github-repo)
     * [3. Add your Slack API token(s)](#3-add-your-slack-api-tokens)
        * [Get a token with OAuth](#get-a-token-with-oauth)
        * [Get a session token](#get-a-session-token)
        * [Optional: Connecting to multiple teams](#optional-connecting-to-multiple-teams)
        * [Optional: Secure the tokens](#optional-secure-the-tokens)
  * [Commands and options](#commands-and-options)
     * [Threads](#threads)
     * [Emoji characters and tab completions of emoji names](#emoji-characters-and-tab-completions-of-emoji-names)
     * [Cursor and mouse mode](#cursor-and-mouse-mode)
  * [Removing a team](#removing-a-team)
  * [Optional settings](#optional-settings)
  * [FAQ](#faq)
     * [How do I keep the buffers sorted alphabetically or with a custom order?](#how-do-i-keep-the-buffers-sorted-alphabetically-or-with-a-custom-order)
     * [How do I group the buffers by team in the buffer list?](#how-do-i-group-the-buffers-by-team-in-the-buffer-list)
     * [How can I get system wide notifications for messages?](#how-can-i-get-system-wide-notifications-for-messages)
        * [Local notifications on Linux](#local-notifications-on-linux)
        * [Local notifications on macOS](#local-notifications-on-macos)
        * [Remote notifications](#remote-notifications)
     * [How do I send messages with multiple lines?](#how-do-i-send-messages-with-multiple-lines)
        * [For WeeChat < 4.0.0](#for-weechat--400)
  * [Known issues](#known-issues)
  * [Debugging](#debugging)
  * [Support](#support)

Features
--------
  * [Threads](#threads) support
  * Slack status support
  * Slash commands (including custom ones)
  * Upload to slack capabilities
  * Emoji reactions
  * Edited messages work just like the official clients, where the original message changes and has (edited) appended.
  * Unfurled urls dont generate a new message, but replace the original with more info as it is received.
  * Regex message editing (s/oldtext/newtext/)
  * Smarter redraw of dynamic buffer info (much lower CPU %)
  * Multiple Teams supported. Just add multiple api tokens separated by commas
  * Replays history automatically during startup. (and sets read marker to the correct position in history)
  * Open channels synchronized with Slack. When you open/close a channel on another client it is reflected in wee-slack
  * Colorized nicks in chat
  * Supports bidirectional slack read notifications for all channels. (never reread the same messages on the web client or other devices).
  * Typing notification, so you can see when others are typing, and they can see when you type. Appears globally for direct messages
  * Away/back status handling
  * Expands/shows metadata for things like tweets/links
  * *Super fun* debug mode. See what the websocket is saying

Contributing
------------

See [docs/contributing.md](./docs/contributing.md).

Dependencies
------------
  * WeeChat 2.2+ http://weechat.org/
  * websocket-client https://pypi.python.org/pypi/websocket-client/
    * Since WeeChat 2.6, Python 3 modules are required, see https://weechat.org/blog/post/2019/07/02/Python-3-by-default
  * Some distributions package WeeChat's plugin functionalities in separate packages.
    Be sure that your WeeChat supports python plugins. Under Debian, install `weechat-python`

Setup
-----

### 1. Install dependencies

**Arch Linux**: `pacman -S python-websocket-client`

**Debian/Ubuntu**: `apt install weechat-python python3-websocket`

**Fedora**: `dnf install python3-websocket-client`

**FreeBSD**: `pkg install py36-websocket-client`

**OpenBSD**: `pkg_add weechat-python py3-websocket-client`

**Other**: `python3 -m pip install websocket-client`

### 2. Install and load wee-slack

#### From the WeeChat script repo

The easiest way to install wee-slack is from inside WeeChat by running:
`/script install slack.py`

This will install and load it and enable automatically loading it when WeeChat
starts.

#### From the GitHub repo

Alternatively, you can download the `wee_slack.py` script from the GitHub repo,
either from the latest release or from the master branch and place it under the
`python/` directory in [the WeeChat data files
directory](https://weechat.org/files/doc/stable/weechat_user.en.html#files_and_directories).

If you use the default XDG directories, this will be
`$XDG_DATA_HOME/weechat/python`, or `~/.local/share/weechat/python` if
`$XDG_DATA_HOME` is not set. If you use the old single directory, it will be
`~/.weechat/python`.

If you use this method and want it to load automatically when WeeChat starts,
you have to create a symlink from the `autoload` directory to the script.

E.g. to install and automatically load the latest version from the master
branch when using `~/.local/share/weechat`:

```
mkdir -p ~/.local/share/weechat/python/autoload
cd ~/.local/share/weechat/python
curl -O https://raw.githubusercontent.com/wee-slack/wee-slack/master/wee_slack.py
ln -s ../wee_slack.py autoload
```

If you already had WeeChat running when installing the script, or if you didn't
enable autoload, you have to [load the
script](https://weechat.org/files/doc/stable/weechat_scripting.en.html#load_script)
by running this inside WeeChat: `/script load wee_slack.py`

### 3. Add your Slack API token(s)

There are two types of tokens that can be used, OAuth tokens and session
tokens. The official way to get a token is to use OAuth. However, this has
several drawbacks, so an alternative way is to pull a session token out of the
web client.

Drawbacks of OAuth tokens:
- If the team is restricting app installations, wee-slack has to be approved by
  an admin.
- For free teams, wee-slack will use one of the ten app slots.
- The subscribe and unsubscribe commands won't work.
- Threads can only be marked as read locally, it won't sync to Slack. This
  means they will be unread again after reloading the script.

Drawbacks of session tokens:
- These tokens can't be revoked, so be careful not to loose them.
- They are not officially supported, and may stop working at any time.

#### Get a token with OAuth

Log in to Slack:

```
/slack register
```

This command prints a link you should open in your browser to authorize WeeChat
with Slack. If the page shows a different team than the one you want to add,
you can change the team in the top right corner of the page.

Once you've accomplished this, the page will show a command which you should
run in WeeChat. The command is of the form:

```
/slack register <code>
```

Note that this will store your token in plain text in the
`plugins.var.python.slack.slack_api_token` option. See "Optional: Secure the
tokens" below for how to secure it.

Your Slack team is now added, and you can complete the setup by reloading the
wee-slack script.

```
/python reload slack
```

Note that by default GitHub Pages will see a temporary code used to create your
token (but not the token itself). If you're worried about this, you can use the
`-nothirdparty` option, though the process will be a bit less user friendly.

#### Get a session token

1. Open and sign into the [Slack customization page](https://my.slack.com/customize). Check that you end up on the correct team.
2. Open the developer console (`Ctrl+Shift+J`/`Cmd+Opt+J` in Chrome and `Ctrl+Shift+K`/`Cmd+Opt+K` in Firefox).
3. Paste and run this code: `window.prompt("Session token:", TS.boot_data.api_token)`
4. A prompt with the token will appear. Copy the token.
5. In the developer console go to Application in Chrome or Storage in Firefox.
6. Expand Cookies and click on the domain.
7. Find the cookie named `d` and copy the value.
8. Return to WeeChat and run `/slack register <token>:<cookie>`.
9. Reload the script with `/python reload slack`.

Note that this will store your token in plain text in the
`plugins.var.python.slack.slack_api_token` option. See "Optional: Secure the
tokens" below for how to secure it.

Note that if you log in or out of any teams in your browser, the cookie will be
invalidated, and you will have to update it.

Note that in some cases it may be necessary to include the `d-s` cookie as
well. If so, you can supply it in this format `<token>:d=<d_cookie>;d-s=<d-s_cookie>`.

If you use Chrome or Firefox, you can run the `extract_token_from_browser.py`
script to get the tokens and cookies for all the teams you're logged into:

```
./extract_token_from_browser.py <browser>
```

(Note this script requires the Plyvel, PyCryptodome and SecretStorage libraries for Chrome and may require the python-snappy library for Firefox.)

#### Optional: Connecting to multiple teams

You can run the register command multiple times to connect to multiple teams.
If you set the token option yourself, you should separate the tokens with
commas.

```
/mute /set plugins.var.python.slack.slack_api_token <token1>,<token2>,<token3>
```

The `/mute` prefix is to prevent "Option changed ..." from being printed to the
core buffer, so your token is not logged in your buffer logs.

#### Optional: Secure the tokens

The tokens you add will be stored as plain text in the option
`plugins.var.python.slack.slack_api_token`. If you don't want to store your API
token in plain text you can use the secure features of WeeChat:

```
/secure passphrase this is a super secret password
/secure set slack_token <YOUR_SLACK_TOKEN>
/set plugins.var.python.slack.slack_api_token ${sec.data.slack_token}
```

Note that you will have to move your tokens manually from
`plugins.var.python.slack.slack_api_token` to the secure variable after each
time you run `/slack register <code>`.

Commands and options
--------------------

For the available options see [docs/Options.md](docs/Options.md) or run this command:
```
/set slack
```

Most options require that you reload the script with `/python reload slack`
after changing it to take effect.

For the available commands see [docs/Commands.md](docs/Commands.md) or run this command:
```
/slack help
```

In addition to the commands listed with `/slack help`, most normal IRC
commands, like `/join`, `/part`, `/query`, `/msg`, `/me`, `/topic`, `/away` and
`/whois` work normally. See [WeeChat's
documentation](https://weechat.org/files/doc/stable/weechat_user.en.html) or
`/help <cmd>` if you are unfamiliar with these.

There are also some special messages you can send:

Modify previous message using regex:
```
s/old text/new text/
```

Modify 3rd previous message using regex:
```
3s/old text/new text/
```

The regex also supports the flags `g` for replacing all instances, `i` for
ignoring case, `m` for making `^` and `$` match the start/end of each line and
`s` for making `.` match a newline too. Use them by appending one or more of
them to the regex:
```
s/old text/new text/gi
```

Delete previous message:
```
s///
```

Add a reaction to the nth last message. The number can be omitted and defaults to the last message. The `+` can be replaced with a `-` to remove a reaction instead.
```
3+:smile:
```

To send a command as a normal message instead of performing the action, prefix it with a slash or a space, like so:
```
//slack
 s/a/b/
```

### Threads

Start a new thread on the most recent message The number indicates which message in the buffer to reply to, in reverse time order:
```
/reply 1 here is a threaded reply to the most recent message!
```

Open an existing thread as a channel. The argument is the thread identifier, which is printed in square brackets with every threaded message in a channel:
```
/thread af8
```

To access the last thread in a channel a shorthand is available:
```
/thread
```

Label a thread with a memorable name. The above command will open a channel called af8, but perhaps you want to call it "meetingnotes". To do so, select that buffer and type:
```
/label meetingnotes
```
_Note: labels do not persist once a thread buffer is closed_

### Emoji characters and tab completions of emoji names

To enable rendering of emoji characters and tab completion of emoji names, copy
or symlink the
[`weemoji.json`](https://github.com/wee-slack/wee-slack/blob/master/weemoji.json)
file to your WeeChat config directory (e.g. `~/.local/share/weechat` or
`~/.weechat`). If doing this after starting wee-slack, you will have to reload
it by running `/python reload slack`.

Emoji names can be completed by typing colon and the start of the emoji name
and pressing tab.

### Cursor and mouse mode

The cursor mode and mouse mode can be used to interact with older messages, for editing, deleting, reacting and replying to a message. Mouse mode can be toggled by pressing `Alt`+`m` and cursor mode can be entered by running `/cursor` (see `/help cursor`).

If mouse mode is enabled, the default behavior when right-clicking on a message is to paste its id in the input. It can be used in `/reply`, `s/` substitution/deletion and in `+:emoji:` commands instead of a message number.
It can also be used as an argument to the `/slack linkarchive` command.

In cursor mode, the `M` key achieves the same result (memo: the default for WeeChat is to paste the message with `m`, `M` simply copies the id).
In addition, `R` will prepare a `/reply id` and `D` will delete the message (provided it's yours).
`T` will open the thread associated to a message, equivalent to `/thread id`
`L` will call the `/slack linkarchive` command behind the hood and paste it to the current input.

Please see WeeChat's documentation about [how to use the cursor mode](https://weechat.org/files/doc/stable/weechat_user.en.html#key_bindings_cursor_context) or [adapt the bindings](https://weechat.org/files/doc/stable/weechat_user.en.html#command_weechat_key) to your preference.

Default key bindings:
```
/key bindctxt mouse @chat(python.*):button2 hsignal:slack_mouse
/key bindctxt cursor @chat(python.*):D hsignal:slack_cursor_delete
/key bindctxt cursor @chat(python.*):L hsignal:slack_cursor_linkarchive
/key bindctxt cursor @chat(python.*):M hsignal:slack_cursor_message
/key bindctxt cursor @chat(python.*):R hsignal:slack_cursor_reply
/key bindctxt cursor @chat(python.*):T hsignal:slack_cursor_thread
```

Note that if these keys are already defined, they will not be overwritten by wee-slack. In that case, you will have to define your own key bindings by running the above commands modified to your liking.

hsignals `slack_mouse` and `slack_cursor_message` currently have the same meaning but may be subject to evolutions.

Removing a team
---------------

You may remove a team by removing its token from the dedicated comma-separated list:
```
/set plugins.var.python.slack.slack_api_token "xoxp-XXXXXXXX,xoxp-XXXXXXXX"
```

You can use tab completion after the key to complete the current value. To see
which token belongs to which team, run `/slack teams`.

After removing the token, you have to reload wee-slack with `/python reload slack`.

Optional settings
-----------------

Show typing notification in main bar (slack_typing_notice):
```
/set weechat.bar.status.items [buffer_count],[buffer_plugin],buffer_number+:+buffer_name+{buffer_nicklist_count}+buffer_filter,[hotlist],completion,scroll,slack_typing_notice
```

Show channel name in hotlist after activity
```
/set weechat.look.hotlist_names_level 14
```

FAQ
---

### How do I keep the buffers sorted alphabetically or with a custom order?

Install the script
[autosort.py](https://weechat.org/scripts/source/autosort.py.html/) by running
`/script install autosort.py`. This will keep your buffer list sorted
alphabetically by default. If you want to customize it, run `/help autosort`.

### How do I group the buffers by team in the buffer list?

Run `/set irc.look.server_buffer independent` and install the
[autosort.py](https://weechat.org/scripts/source/autosort.py.html/) script
mentioned in the previous question.

### How can I get system wide notifications for messages?

#### Local notifications on Linux

Use [this trigger](https://github.com/weechat/weechat/wiki/Triggers#show-a-libnotify-desktop-notification-via-notify-send).
You need the `notify-send` command, or alternatively replace it with another
command in the trigger.

#### Local notifications on macOS

Use [the notification_center.py script](https://weechat.org/scripts/source/notification_center.py.html/). You can install it with `/script install notification_center.py`.

#### Remote notifications

There are many scripts in the [scripts repo](https://weechat.org/scripts/tag/notify/)
for various use cases. Note that not all may work with wee-slack, so you will
have to test them.

### How do I send messages with multiple lines?

With WeeChat >= 4.0.0 this is supported out of the box. You can either press
Alt+Enter to insert a line break, or paste something containing multiple lines.

For older versions of WeeChat, continue reading the next section.

#### For WeeChat < 4.0.0

You have to install a script to be able to send multiple lines, e.g. the
`multiline.pl` script with: `/script install multiline.pl`

By default it will wait for one second after you press enter, and if you type
another character in that period, it will insert the character on a newline,
and if you don't type anything it will send the message. If you rather want to
use a separate key to insert a newline, and have the enter key send the message
immediately, you can run these commands:

```
/set plugins.var.perl.multiline.magic_paste_only on
/key bind meta-ctrl-M /input insert \n
```

This will bind meta-enter (which is usually alt-enter) to insert the newline.
Replace `meta-ctrl-M` with something else if you want to use a different key
combination.

The `multiline.pl` script will also let you edit pasted text which incudes
newlines before you send the message. If this is not working, you may try to
run the commands below. At least in the `kitty` terminal, it won't work by
default, but should work after running these commands:

```
/set plugins.var.perl.multiline.weechat_paste_fix "off"
/key bind ctrl-J /input magic_enter
```

You may also want to disable WeeChat's paste prompt, since that is not necessary
when using `multiline.pl`:

```
/set weechat.look.paste_max_lines -1
```

Known issues
------------

Not all issues are listed here (see
[issues](https://github.com/wee-slack/wee-slack/issues) for all), but these are
some noteworthy:

- If you set `background_load_all_history` to `false`:
  - Channels will not be shown as unread when wee-slack loads, even if there
    are unread messages. Messages which arrive after wee-slack has loaded
    however will mark the channel as unread.
  - If messages arrive while the connection to Slack is lost (e.g. during
    suspend), they will not appear in the hotlist.
- If you use an OAuth token or a legacy token instead of a session token:
  - Threads can only be marked as read locally, it won't sync to Slack. This
    means they will be unread again after reloading the script.

Debugging
---------

To help debugging you can enable debugging output about what wee-slack is doing
by enabling debug mode and changing debug level (between 0 and 5, default is 3,
decrease to increase logging and vice versa). Enabling this will open a new
buffer `slack-debug` where the messages are printed. Enable it and change level
by running:

```
/set plugins.var.python.slack.debug_mode on
/set plugins.var.python.slack.debug_level 0
```

You can also dump all the JSON responses received from the API in
`/tmp/weeslack-debug/`. This requires a script reload after enabling. Enable it
with:

```
/set plugins.var.python.slack.record_events true
/python reload slack
```

Support
-------

wee-slack is provided without any warranty whatsoever, but you are welcome to ask questions in #wee-slack on [Libera.Chat](https://libera.chat/).


.. raw:: html

.. image:: https://badge.fury.io/py/foolbox.svg
   :target: https://badge.fury.io/py/foolbox

.. image:: https://readthedocs.org/projects/foolbox/badge/?version=latest
    :target: https://foolbox.readthedocs.io/en/latest/

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
   :target: https://github.com/ambv/black

.. image:: https://joss.theoj.org/papers/10.21105/joss.02607/status.svg
   :target: https://doi.org/10.21105/joss.02607

===============================================================================================================================
Foolbox: Fast adversarial attacks to benchmark the robustness of machine learning models in PyTorch, TensorFlow, and JAX
===============================================================================================================================

`Foolbox <https://foolbox.jonasrauber.de>`_ is a **Python library** that lets you easily run adversarial attacks against machine learning models like deep neural networks. It is built on top of EagerPy and works natively with models in `PyTorch <https://pytorch.org>`_, `TensorFlow <https://www.tensorflow.org>`_, and `JAX <https://github.com/google/jax>`_.

🔥 Design
----------

**Foolbox 3** has been rewritten from scratch
using `EagerPy <https://github.com/jonasrauber/eagerpy>`_ instead of
NumPy to achieve native performance on models
developed in PyTorch, TensorFlow and JAX, all with one code base without code duplication.

- **Native Performance**: Foolbox 3 is built on top of EagerPy and runs natively in PyTorch, TensorFlow, and JAX and comes with real batch support.
- **State-of-the-art attacks**: Foolbox provides a large collection of state-of-the-art gradient-based and decision-based adversarial attacks.
- **Type Checking**: Catch bugs before running your code thanks to extensive type annotations in Foolbox.

📖 Documentation
-----------------

- **Guide**: The best place to get started with Foolbox is the official `guide <https://foolbox.jonasrauber.de>`_.
- **Tutorial**: If you are looking for a tutorial, check out this `Jupyter notebook <https://github.com/jonasrauber/foolbox-native-tutorial/blob/master/foolbox-native-tutorial.ipynb>`_ |colab|.
- **Documentation**: The API documentation can be found on `ReadTheDocs <https://foolbox.readthedocs.io/en/stable/>`_.

.. |colab| image:: https://colab.research.google.com/assets/colab-badge.svg
   :target: https://colab.research.google.com/github/jonasrauber/foolbox-native-tutorial/blob/master/foolbox-native-tutorial.ipynb

🚀 Quickstart
--------------

.. code-block:: bash

   pip install foolbox

Foolbox is tested with Python 3.8 and newer - however, it will most likely also work with version 3.6 - 3.8. To use it with `PyTorch <https://pytorch.org>`_, `TensorFlow <https://www.tensorflow.org>`_, or `JAX <https://github.com/google/jax>`_, the respective framework needs to be installed separately. These frameworks are not declared as dependencies because not everyone wants to use and thus install all of them and because some of these packages have different builds for different architectures and CUDA versions. Besides that, all essential dependencies are automatically installed.

You can see the versions we currently use for testing in the `Compatibility section <#-compatibility>`_ below, but newer versions are in general expected to work.

🎉 Example
-----------

.. code-block:: python

   import foolbox as fb

   model = ...
   fmodel = fb.PyTorchModel(model, bounds=(0, 1))

   attack = fb.attacks.LinfPGD()
   epsilons = [0.0, 0.001, 0.01, 0.03, 0.1, 0.3, 0.5, 1.0]
   _, advs, success = attack(fmodel, images, labels, epsilons=epsilons)

More examples can be found in the `examples <./examples/>`_ folder, e.g.
a full `ResNet-18 example <./examples/single_attack_pytorch_resnet18.py>`_.

📄 Citation
------------

If you use Foolbox for your work, please cite our `JOSS paper on Foolbox Native (i.e., Foolbox 3.0) <https://doi.org/10.21105/joss.02607>`_ and our `ICML workshop paper on Foolbox <https://arxiv.org/abs/1707.04131>`_ using the following BibTeX entries:

.. code-block::

   @article{rauber2017foolboxnative,
     doi = {10.21105/joss.02607},
     url = {https://doi.org/10.21105/joss.02607},
     year = {2020},
     publisher = {The Open Journal},
     volume = {5},
     number = {53},
     pages = {2607},
     author = {Jonas Rauber and Roland Zimmermann and Matthias Bethge and Wieland Brendel},
     title = {Foolbox Native: Fast adversarial attacks to benchmark the robustness of machine learning models in PyTorch, TensorFlow, and JAX},
     journal = {Journal of Open Source Software}
   }

.. code-block::

   @inproceedings{rauber2017foolbox,
     title={Foolbox: A Python toolbox to benchmark the robustness of machine learning models},
     author={Rauber, Jonas and Brendel, Wieland and Bethge, Matthias},
     booktitle={Reliable Machine Learning in the Wild Workshop, 34th International Conference on Machine Learning},
     year={2017},
     url={http://arxiv.org/abs/1707.04131},
   }

👍 Contributions
-----------------

We welcome contributions of all kind, please have a look at our
`development guidelines <https://foolbox.jonasrauber.de/guide/development.html>`_.
In particular, you are invited to contribute
`new adversarial attacks <https://foolbox.jonasrauber.de/guide/adding_attacks.html>`_.
If you would like to help, you can also have a look at the issues that are
marked with `contributions welcome
<https://github.com/bethgelab/foolbox/issues?q=is%3Aopen+is%3Aissue+label%3A%22contributions+welcome%22>`_.

💡 Questions?
--------------

If you have a question or need help, feel free to open an issue on GitHub.
Once GitHub Discussions becomes publicly available, we will switch to that.

💨 Performance
--------------

Foolbox 3.0 is much faster than Foolbox 1 and 2. A basic `performance comparison`_ can be found in the `performance` folder.

🐍 Compatibility
-----------------

We currently test with the following versions:

* PyTorch 1.10.1
* TensorFlow 2.6.3
* JAX 0.2.517
* NumPy 1.18.1

.. _performance comparison: performance/README.md


# hvac

![Header image](https://raw.githubusercontent.com/hvac/hvac/main/docs/_static/hvac_logo_800px.png)

[HashiCorp](https://hashicorp.com/) [Vault](https://www.vaultproject.io) API client for Python 3.x

[![Build](https://github.com/hvac/hvac/actions/workflows/build-test.yml/badge.svg)](https://github.com/hvac/hvac/actions/workflows/build-test.yml)
[![Lint](https://github.com/hvac/hvac/actions/workflows/lint-and-test.yml/badge.svg)](https://github.com/hvac/hvac/actions/workflows/lint-and-test.yml)
[![codecov](https://codecov.io/gh/hvac/hvac/branch/main/graph/badge.svg)](https://codecov.io/gh/hvac/hvac)
[![Documentation Status](https://readthedocs.org/projects/hvac/badge/)](https://hvac.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/hvac.svg)](https://badge.fury.io/py/hvac)
[![Twitter - @python_hvac](https://img.shields.io/twitter/follow/python_hvac.svg?label=Twitter%20-%20@python_hvac&style=social?style=plastic)](https://twitter.com/python_hvac)
[![Gitter chat](https://badges.gitter.im/hvac/community.png)](https://gitter.im/hvac/community)

Tested against the latest release, HEAD ref, and 3 previous minor versions (counting back from the latest release) of Vault.
Current official support covers Vault v1.4.7 or later.

> **NOTE:**  Support for EOL Python versions will be dropped at the end of 2022.  Starting in 2023, hvac will track
> with the CPython EOL dates.

## Installation

```console
pip install hvac
```

If you would like to be able to return parsed HCL data as a Python dict for methods that support it:

```console
pip install "hvac[parser]"
```

## Documentation

Additional documentation for this module available at: [hvac.readthedocs.io](https://hvac.readthedocs.io/en/stable/usage/index.html):

* [Getting Started](https://hvac.readthedocs.io/en/stable/overview.html#getting-started)
* [Usage](https://hvac.readthedocs.io/en/stable/usage/index.html)
* [Advanced Usage](https://hvac.readthedocs.io/en/stable/advanced_usage.html)
* [Source Reference / Autodoc](https://hvac.readthedocs.io/en/stable/source/index.html)
* [Contributing](https://hvac.readthedocs.io/en/stable/contributing.html)
* [Changelog](https://hvac.readthedocs.io/en/stable/changelog.html)


.. -*-restructuredtext-*-

.. image:: https://github.com/ubernostrum/django-registration/workflows/CI/badge.svg
   :alt: CI status image
   :target: https://github.com/ubernostrum/django-registration/actions?query=workflow%3ACI

This is a user-registration application for `Django
<https://www.djangoproject.com/>`_. There are two registration
workflows (one-step, and two-step with activation) built in, and it's
designed to be extensible and support building additional workflows.

To get started, check out `the documentation
<https://django-registration.readthedocs.io/>`_.