QR Code encoder and Micro QR Code encoder
=========================================

Pure Python QR Code generator with no dependencies.

This package implements ISO/IEC 18004:2015(E) "QR Code bar code symbology
specification" and produces QR Codes and Micro QR Codes with nearly no effort.
It supports the `Structured Append mode <https://segno.readthedocs.io/en/stable/structured-append.html>`_
which splits a message across several QR codes.

Segno (Italian for "sign" / "symbol") provides several serialization formats
like Scalable Vector Graphics (SVG), Encapsulated PostScript (EPS),
Portable Network Graphics (PNG), Portable Document Format (PDF), Netpbm (PAM, PBM, PPM),
LaTeX (PGF/TikZ), X PixMap (XBM), and X Bitmap (XPM) etc.
None of these serializers require an external lib.
Further, it provides several high level functions to create QR Codes which encode
`contact data (vCard, MeCard) <https://segno.readthedocs.io/en/stable/contact-information.html>`_,
`EPC QR Codes <https://segno.readthedocs.io/en/stable/epc-qrcodes.html>`_,
or `WIFI QR Codes <https://segno.readthedocs.io/en/stable/special-qrcode-factories.html#create-a-qr-code-for-a-wifi-configuration>`_.

The project provides more than 1500 test cases (coverage >= 98%) to verify a
standard conform QR Code and Micro QR Code generation acc. to ISO/IEC 18004:2015(E).

Unique features
---------------
* Pure Python QR Code generator
* No dependencies
* A lot of `serialization formats <https://segno.readthedocs.io/en/stable/serializers.html#available-serializers>`_ (SVG, PNG, EPS, PDF, ...)
* `Fastest (pure Python) QR Code encoder <https://segno.readthedocs.io/en/stable/comparison-qrcode-libs.html#performance>`_
* Micro QR Codes
* `Structured Append mode <https://segno.readthedocs.io/en/stable/structured-append.html>`_
* `Hanzi mode <https://segno.readthedocs.io/en/stable/qrcode-modes.html#hanzi-mode>`_
* `Command line interface <https://segno.readthedocs.io/en/stable/command-line.html>`_
* `Simple, user-friendly API <https://segno.readthedocs.io/en/stable/make.html>`_

.. code-block:: python

    import segno
    qrcode = segno.make('Yellow Submarine')
    qrcode.save('yellow-submarine.png')

* `Colorful QR codes <https://segno.readthedocs.io/en/stable/colorful-qrcodes.html>`_

  .. image:: https://github.com/heuer/segno/raw/master/docs/_static/colorful/qrcode_yellow-submarine.png
    :alt: Colorful 7-H QR code encoding "Yellow Submarine"

  ... works also with Micro QR codes

  .. image:: https://github.com/heuer/segno/raw/master/docs/_static/colorful/micro_qrcode_rain.png
    :alt: Colorful M4-Q Micro QR code encoding "Rain"

* `Artistic QR Codes <https://segno.readthedocs.io/en/stable/artistic-qrcodes.html>`_
  (requires the `qrcode-artistic <https://github.com/heuer/qrcode-artistic>`_ plug-in)

  .. image:: https://github.com/heuer/segno/raw/master/docs/_static/artistic/letitbe.jpg
    :alt: Animated 3-H QR code encoding "The Beatles -- Let It Be"

  ... animated QR codes are supported as well

  .. image:: https://github.com/heuer/segno/raw/master/docs/_static/artistic/abbey-road.webp
    :alt: Animated 4-H QR code encoding "The Beatles -- Abbey Road"

Installation
------------

Use ``pip`` to install segno from PyPI::

    $ pip install segno

conda-forge
^^^^^^^^^^^

The library is also available at `conda-forge <https://conda-forge.org/>`_
(`conda-forge project page <https://anaconda.org/conda-forge/segno>`_)::

    $ conda install -c conda-forge segno

Debian
^^^^^^

::

    $ apt-get install python3-segno

Arch Linux
^^^^^^^^^^

::

    $ pacman -S python-segno

Usage
-----

Command line
^^^^^^^^^^^^

The command line script prints a QR code to the terminal::

    $ segno "Comfortably Numb"

To serialize a QR code, use the "output" argument::

    $ segno -o=raincoat.svg "Famous Blue Raincoat"
    $ segno --scale 10 --dark darkblue --border 0 --output=fire.svg "Who by Fire"
    $ segno --scale 10 --light transparent --output=miracle.png "Waiting for the Miracle"

Library
^^^^^^^

.. code-block:: python

    >>> import segno
    >>> # Let Segno choose the minimal version and an optimal (maximal) error
    >>> # level without changing the minimal version
    >>> qrcode = segno.make('Up Jumped the Devil')
    >>> qrcode.designator  # Returns the QR code version and the error correction level
    '2-Q'
    >>> qrcode.save('up-jumped-the-devil.png')  # Save as PNG
    >>> qrcode.save('up-jumped-the-devil-2.png', scale=10)  # Scaling factor 10
    >>> qrcode.save('up-jumped-the-devil-3.png', light=None)  # Transparent light modules
    >>> qrcode.save('up-jumped-the-devil.pdf', scale=10)  # Save as PDF
    >>> # SVG drawing the dark modules in "dark blue"
    >>> qrcode.save('up-jumped-the-devil.svg', scale=10, dark='darkblue')

If the content to encode is small enough, a Micro QR code is generated:

.. code-block:: python

    >>> import segno
    >>> qrcode = segno.make('RAIN')
    >>> qrcode.is_micro
    True
    >>> qrcode.designator
    'M2-M'

If this behaviour is not desired, the user may set ``micro`` to ``False``

.. code-block:: python

    >>> import segno
    >>> qrcode = segno.make('RAIN', micro=False)
    >>> qrcode.is_micro
    False
    >>> qrcode.designator
    '1-H'

Or use the factory functions ``segno.make_qr()`` which generates always QR codes
(never Micro QR codes) or ``segno.make_micro()`` which returns always
Micro QR codes (or raises an error if the content is too large for a Micro QR code).

.. code-block:: python

    >>> import segno
    >>> qrcode_micro = segno.make_micro('THE BEATLES')
    >>> qrcode_micro.designator
    'M3-M'
    >>> qrcode = segno.make_qr('THE BEATLES')  # Same content but enforce a QR Code
    >>> qrcode.designator
    '1-Q'
    >>> # This won't work since the data does not fit into a Micro QR Code M1 - M4
    >>> micro_qrcode = segno.make_micro('Nick Cave and the Bad Seeds')
    Traceback (most recent call last):
        ...
    DataOverflowError: Data too large. No Micro QR Code can handle the provided data

All factory functions use the same parameters to specify the desired error
level, version, data mask etc., see `Segno's documentation`_ for details.

Documentation
-------------
Read the online documentation at <https://segno.readthedocs.io/>

Trademark
---------
"QR Code" and "Micro QR Code" are registered trademarks of DENSO WAVE INCORPORATED.

.. _Segno's documentation: https://segno.readthedocs.io/


# PyBIDS
[![DOI](https://joss.theoj.org/papers/10.21105/joss.01294/status.svg)](https://doi.org/10.21105/joss.01294)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2537312.svg)](https://doi.org/10.5281/zenodo.2537312)

[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/bids-standard/pybids/master)
[![PyPI version](https://badge.fury.io/py/pybids.svg)](https://badge.fury.io/py/pybids)
[![Conda version](https://img.shields.io/conda/vn/conda-forge/pybids)](https://anaconda.org/conda-forge/pybids)

PyBIDS is a Python library to centralize interactions with datasets conforming
BIDS (Brain Imaging Data Structure) format.  For more information about BIDS
visit https://bids.neuroimaging.io.

PyBIDS currently supports Python 3 on POSIX operating systems (including Mac OS).  Windows is not officially supported, though most PyBIDS functionality will probably work fine.

## Installation
PyBIDS is most easily installed from pip. To install the latest official release:

> pip install pybids

Or, alternatively via conda:

> conda install -c conda-forge pybids

If you want to live on the bleeding edge, you can install from master:

> pip install git+https://github.com/bids-standard/pybids.git

### Dependencies
PyBIDS has a number of dependencies. The core querying functionality requires only the `BIDS-Validator` package. However, most other modules require the core Python neuroimaging stack: `numpy`, `scipy`, `pandas`, and `nibabel`. The `reports` module additionally requires `num2words`. By default, all dependencies will be installed with pybids (if they aren't already available).

## Usage
Get started by checking out [the documentation](https://bids-standard.github.io/pybids)!

Or you can start at [our tutorial](https://bids-standard.github.io/pybids/examples/pybids_tutorial.html)! You can run it interactively without installing anything via [binder](https://mybinder.org/v2/gh/bids-standard/pybids/master). Click on the link and then navigate to `doc/examples/pybids_tutorial.md` to explore.

## Development and testing
PyBIDS uses [tox](https://tox.wiki/) to manage testing environments and ensure that the same
commands can easily be run locally and in CI.

Install tox with:

```
pip install tox
```

To run tests with standard, minimal, or pre-release dependencies, use:

```
tox run -e [full|min|pre]
```

To run with a specific version, also specify `py3X`:

```
tox run -e py311-full
```

See `tox` documentation for more detail.

## How to cite
To credit PyBIDS in your work, please cite both the [JOSS paper](https://joss.theoj.org/papers/10.21105/joss.01294) and the [Zenodo archive](https://zenodo.org/record/3363985). The former provides a high level description of the package, and the latter points to a permanent record of all PyBIDS versions (we encourage you to cite the specific version you used). Example citations (for PyBIDS 0.9.3):

Yarkoni et al., (2019). PyBIDS: Python tools for BIDS datasets. Journal of Open Source Software, 4(40), 1294, https://doi.org/10.21105/joss.01294

Yarkoni, Tal, Markiewicz, Christopher J., de la Vega, Alejandro, Gorgolewski, Krzysztof J., Halchenko, Yaroslav O., Salo, Taylor, … Blair, Ross. (2019, August 8). bids-standard/pybids: 0.9.3 (Version 0.9.3). Zenodo. https://doi.org/10.5281/zenodo.3363985

## Community guidelines
Bug reports, feedback, and other contributions to PyBIDS are welcome. To report a bug, request a feature, or raise a technical (non-usage-related) question for discussion, please [open an issue on GitHub](https://github.com/bids-standard/pybids/issues). Requests for support and questions about usage (where no bug is suspected) should be posted on the [NeuroStars](https://neurostars.org) forum. For questions about the [BIDS specification](https://github.com/bids-standard/bids-specification) or [BIDS-Validator](https://github.com/bids-standard/bids-validator), please see the corresponding repositories. For general BIDS-related discussion, see the [bids-discussion](https://groups.google.com/forum/#!forum/bids-discussion) mailing list.

Pull requests are always welcome. If you have any doubts about the suitability of a PR, or want to discuss implementation-related issues, feel free to open an issue for discussion.


========================================
 Neuro Digital Signal Processing Toolbox
========================================

|ProjectStatus| |Version| |BuildStatus| |Coverage| |License| |PythonVersions| |Publication|

.. |ProjectStatus| image:: https://www.repostatus.org/badges/latest/active.svg
   :target: https://www.repostatus.org/#active
   :alt: build status

.. |Version| image:: https://img.shields.io/pypi/v/neurodsp.svg
   :target: https://pypi.python.org/pypi/neurodsp/
   :alt: version

.. |BuildStatus| image:: https://github.com/neurodsp-tools/neurodsp/actions/workflows/build.yml/badge.svg
   :target: https://github.com/neurodsp-tools/neurodsp/actions/workflows/build.yml
   :alt: build status

.. |Coverage| image:: https://codecov.io/gh/neurodsp-tools/neurodsp/branch/main/graph/badge.svg
   :target: https://codecov.io/gh/neurodsp-tools/neurodsp
   :alt: coverage

.. |License| image:: https://img.shields.io/pypi/l/neurodsp.svg
   :target: https://opensource.org/licenses/Apache-2.0
   :alt: license

.. |PythonVersions| image:: https://img.shields.io/pypi/pyversions/neurodsp.svg
   :target: https://pypi.python.org/pypi/neurodsp/
   :alt: python versions

.. |Publication| image:: https://joss.theoj.org/papers/10.21105/joss.01272/status.svg
   :target: https://doi.org/10.21105/joss.01272
   :alt: publication

Tools to analyze and simulate neural time series, using digital signal processing.

Overview
--------

`neurodsp` is a collection of approaches for applying digital signal processing, and
related algorithms, to neural time series. It also includes simulation tools for generating
plausible simulations of neural time series.

Available modules in ``NeuroDSP`` include:

- ``filt`` : Filter data with bandpass, highpass, lowpass, or notch filters
- ``timefrequency`` : Estimate instantaneous measures of oscillatory activity
- ``spectral`` : Compute freqeuncy domain features such as power spectra
- ``burst`` : Detect bursting oscillations in neural signals
- ``rhythm`` : Find and analyze rhythmic and recurrent patterns in time series
- ``aperiodic`` : Analyze aperiodic features of neural time series
- ``sim`` : Simulate time series, including periodic and aperiodic signal components
- ``plts`` : Plot neural time series and derived measures
- ``utils`` : Additional utilities for managing time series data

Documentation
-------------

Documentation for the ``NeuroDSP`` module is available `here <https://neurodsp-tools.github.io/neurodsp/>`_.

The documentation includes:

- `Tutorials <https://neurodsp-tools.github.io/neurodsp/auto_tutorials/index.html>`_: which describe and work through each module in NeuroDSP
- `Examples <https://neurodsp-tools.github.io/neurodsp/auto_examples/index.html>`_: demonstrating example applications and workflows
- `API List <https://neurodsp-tools.github.io/neurodsp/api.html>`_: which lists and describes all the code and functionality available in the module
- `Glossary <https://neurodsp-tools.github.io/neurodsp/glossary.html>`_: which defines all the key terms used in the module

If you have a question about using NeuroDSP that doesn't seem to be covered by the documentation, feel free to
open an `issue <https://github.com/neurodsp-tools/neurodsp/issues>`_ and ask!

Dependencies
------------

``NeuroDSP`` is written in Python, and requires Python >= 3.6 to run.

It has the following dependencies:

- `numpy <https://github.com/numpy/numpy>`_
- `scipy <https://github.com/scipy/scipy>`_
- `matplotlib <https://github.com/matplotlib/matplotlib>`_

Optional dependencies:

- `pytest <https://github.com/pytest-dev/pytest>`_ is needed if you want to run the test suite locally

We recommend using the `Anaconda <https://www.anaconda.com/products/individual>`_ distribution to manage these requirements.

Install
-------

The current major release of NeuroDSP is the 2.X.X series.

See the `changelog <https://neurodsp-tools.github.io/neurodsp/changelog.html>`_ for notes on major version releases.

**Stable Release Version**

To install the latest stable release, you can use pip:

.. code-block:: shell

    $ pip install neurodsp

NeuroDSP can also be installed with conda, from the conda-forge channel:

.. code-block:: shell

    $ conda install -c conda-forge neurodsp

**Development Version**

To get the current development version, first clone this repository:

.. code-block:: shell

    $ git clone https://github.com/neurodsp-tools/neurodsp

To install this cloned copy, move into the directory you just cloned, and run:

.. code-block:: shell

    $ pip install .

**Editable Version**

To install an editable version, download the development version as above, and run:

.. code-block:: shell

    $ pip install -e .

Contribute
----------

This project welcomes and encourages contributions from the community!

To file bug reports and/or ask questions about this project, please use the
`Github issue tracker <https://github.com/neurodsp-tools/neurodsp/issues>`_.

To see and get involved in discussions about the module, check out:

- the `issues board <https://github.com/neurodsp-tools/neurodsp/issues>`_ for topics relating to code updates, bugs, and fixes
- the `development page <https://github.com/neurodsp-tools/Development>`_ for discussion of potential major updates to the module

When interacting with this project, please use the
`contribution guidelines <https://github.com/neurodsp-tools/fooof/blob/main/CONTRIBUTING.md>`_
and follow the
`code of conduct <https://github.com/neurodsp-tools/neurodsp/blob/main/CODE_OF_CONDUCT.md>`_.

Reference
---------

If you use this code in your project, please cite:

.. code-block:: text

    Cole, S., Donoghue, T., Gao, R., & Voytek, B. (2019). NeuroDSP: A package for
    neural digital signal processing. Journal of Open Source Software, 4(36), 1272.
    DOI: 10.21105/joss.01272

Direct Link: https://doi.org/10.21105/joss.01272

Bibtex:

.. code-block:: text

    @article{cole_neurodsp:_2019,
        title = {NeuroDSP: A package for neural digital signal processing},
        author = {Cole, Scott and Donoghue, Thomas and Gao, Richard and Voytek, Bradley},
        journal = {Journal of Open Source Software},
        year = {2019},
        volume = {4},
        number = {36},
        issn = {2475-9066},
        url = {https://joss.theoj.org/papers/10.21105/joss.01272},
        doi = {10.21105/joss.01272},
    }

Funding
-------

Supported by NIH award R01 GM134363 from the
`NIGMS <https://www.nigms.nih.gov/>`_.

.. image:: https://www.nih.gov/sites/all/themes/nih/images/nih-logo-color.png
  :width: 400

|


# SHARE/Trove

SHARE is creating a free, open dataset of research (meta)data.

> **Note**: SHARE’s open API tools and services help bring together scholarship distributed across research ecosystems for the purpose of greater discoverability. However, SHARE does not guarantee a complete aggregation of searched outputs. For this reason, SHARE results should not be used for methodological analyses, such as systematic reviews.

[![Coverage Status](https://coveralls.io/repos/github/CenterForOpenScience/SHARE/badge.svg?branch=develop)](https://coveralls.io/github/CenterForOpenScience/SHARE?branch=develop)

## Documentation

### What is this?
see [WHAT-IS-THIS-EVEN.md](./WHAT-IS-THIS-EVEN.md)

### How can I use it?
see [how-to/use-the-api.md](./how-to/use-the-api.md)

### How do I navigate this codebase?
see [ARCHITECTURE.md](./ARCHITECTURE.md)

### How do I run a copy locally?
see [how-to/run-locally.md](./how-to/run-locally.md)

## Running Tests

### Unit test suite

  py.test

### BDD Suite

  behave


.. image:: https://raw.githubusercontent.com/GAA-UAM/scikit-fda/develop/docs/logos/title_logo/title_logo.png
	:alt: scikit-fda: Functional Data Analysis in Python

scikit-fda: Functional Data Analysis in Python
===================================================

|python|_ |build-status| |docs| |Codecov| |repostatus| |versions| |PyPIBadge| |conda| |license| |doi|

Functional Data Analysis, or FDA, is the field of Statistics that analyses
data that depend on a continuous parameter.

This package offers classes, methods and functions to give support to FDA
in Python. Includes a wide range of utils to work with functional data, and its
representation, exploratory analysis, or preprocessing, among other tasks
such as inference, classification, regression or clustering of functional data.
See documentation for further information on the features included in the
package.

Documentation
=============

The documentation is available at
`fda.readthedocs.io/en/stable/ <https://fda.readthedocs.io/en/stable/>`_, which
includes detailed information of the different modules, classes and methods of
the package, along with several examples showing different functionalities.

The documentation of the latest version, corresponding with the develop
version of the package, can be found at
`fda.readthedocs.io/en/latest/ <https://fda.readthedocs.io/en/latest/>`_.

Installation
============
Currently, *scikit-fda* is available in Python versions above 3.8, regardless of the
platform.
The stable version can be installed via PyPI_:

.. code::

    pip install scikit-fda

It is also available from conda-forge:
.. code::

    conda install -c conda-forge scikit-fda

Installation from source
------------------------

It is possible to install the latest version of the package, available in the
develop branch,  by cloning this repository and doing a manual installation.

.. code:: bash

    git clone https://github.com/GAA-UAM/scikit-fda.git
    pip install ./scikit-fda

Make sure that your default Python version is currently supported, or change
the python and pip commands by specifying a version, such as ``python3.8``:

.. code:: bash

    git clone https://github.com/GAA-UAM/scikit-fda.git
    python3.8 -m pip install ./scikit-fda

Requirements
------------
*scikit-fda* depends on the following packages:

* `fdasrsf <https://github.com/jdtuck/fdasrsf_python>`_ - SRSF framework
* `findiff <https://github.com/maroba/findiff>`_ - Finite differences
* `matplotlib <https://github.com/matplotlib/matplotlib>`_ - Plotting with Python
* `multimethod <https://github.com/coady/multimethod>`_ - Multiple dispatch
* `numpy <https://github.com/numpy/numpy>`_ - The fundamental package for scientific computing with Python
* `pandas <https://github.com/pandas-dev/pandas>`_ - Powerful Python data analysis toolkit
* `rdata <https://github.com/vnmabus/rdata>`_ - Reader of R datasets in .rda format in Python
* `scikit-datasets <https://github.com/daviddiazvico/scikit-datasets>`_ - Scikit-learn compatible datasets
* `scikit-learn <https://github.com/scikit-learn/scikit-learn>`_ - Machine learning in Python
* `scipy <https://github.com/scipy/scipy>`_ - Scientific computation in Python
* `setuptools <https://github.com/pypa/setuptools>`_ - Python Packaging

The dependencies are automatically installed.

Citing scikit-fda
=================

Please, if you find this software useful in your work, reference it citing the following paper:

.. code-block::

  @article{ramos-carreno++_2024_scikit-fda,
    author = {Ramos-Carreño, Carlos and Torrecilla, José L. and Carbajo Berrocal, Miguel and Marcos Manchón, Pablo and Suárez, Alberto},
    doi = {10.18637/jss.v109.i02},
    journal = {Journal of Statistical Software},
    month = may,
    title = {{scikit-fda: A Python Package for Functional Data Analysis}},
    url = {https://www.jstatsoft.org/article/view/v109i02},
    volume = {109},
    year = {2024}
  }

You can additionally cite the software repository itself using:

.. code-block::

  @misc{ramos-carreno++_2024_scikit-fda-repo,
    author = {The scikit-fda developers},
    doi = {10.5281/zenodo.3468127},
    month = feb,
    title = {scikit-fda: Functional Data Analysis in Python},
    url = {https://github.com/GAA-UAM/scikit-fda},
    year = {2024}
  }

If you want to reference a particular version for reproducibility, check the version-specific DOIs available in Zenodo.

Contributions
=============
All contributions are welcome. You can help this project grow in multiple ways,
from creating an issue, reporting an improvement or a bug, to doing a
repository fork and creating a pull request to the development branch.

The people involved at some point in the development of the package can be
found in the `contributors
file <https://github.com/GAA-UAM/scikit-fda/blob/develop/THANKS.txt>`_.

.. Citation
   ========
   If you find this project useful, please cite:

   .. todo:: Include citation to scikit-fda paper.

License
=======

The package is licensed under the BSD 3-Clause License. A copy of the
license_ can be found along with the code.

.. _examples: https://fda.readthedocs.io/en/latest/auto_examples/index.html
.. _PyPI: https://pypi.org/project/scikit-fda/
.. _conda-forge: https://anaconda.org/conda-forge/scikit-fda/

.. |python| image:: https://img.shields.io/pypi/pyversions/scikit-fda.svg
.. _python: https://badge.fury.io/py/scikit-fda

.. |build-status| image:: https://github.com/GAA-UAM/scikit-fda/actions/workflows/tests.yml/badge.svg?event=push
    :alt: build status
    :scale: 100%
    :target: https://github.com/GAA-UAM/scikit-fda/actions/workflows/tests.yml

.. |docs| image:: https://readthedocs.org/projects/fda/badge/?version=latest
    :alt: Documentation Status
    :scale: 100%
    :target: http://fda.readthedocs.io/en/latest/?badge=latest

.. |Codecov| image:: https://codecov.io/gh/GAA-UAM/scikit-fda/branch/develop/graph/badge.svg
.. _Codecov: https://app.codecov.io/gh/GAA-UAM/scikit-fda

.. |repostatus| image:: https://www.repostatus.org/badges/latest/active.svg
   :alt: Project Status: Active – The project has reached a stable, usable state and is being actively developed.
   :target: https://www.repostatus.org/#active

.. |versions| image:: https://img.shields.io/pypi/pyversions/scikit-fda
   :alt: PyPI - Python Version
   :scale: 100%

.. |PyPIBadge| image:: https://badge.fury.io/py/scikit-fda.svg
.. _PyPIBadge: https://badge.fury.io/py/scikit-fda

.. |conda| image:: https://img.shields.io/conda/vn/conda-forge/scikit-fda
    :alt: Available in Conda
    :scale: 100%
    :target: https://anaconda.org/conda-forge/scikit-fda

.. |license| image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
.. _license: https://github.com/GAA-UAM/scikit-fda/blob/master/LICENSE.txt

.. |doi| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.3468127.svg
    :target: https://doi.org/10.5281/zenodo.3468127


|GitHub Actions status| |PyPI Version| |Codecov| |Gitter Chat|

ufo2ft
======

ufo2ft ("UFO to FontTools") is a fork of
`ufo2fdk <https://github.com/typesupply/ufo2fdk>`__ whose goal is to
generate OpenType font binaries from UFOs without the FDK dependency.

The library provides two functions, ``compileOTF`` and ``compileTTF``,
which work exactly the same way:

.. code:: python

    from defcon import Font
    from ufo2ft import compileOTF
    ufo = Font('MyFont-Regular.ufo')
    otf = compileOTF(ufo)
    otf.save('MyFont-Regular.otf')

In most cases, the behavior of ufo2ft should match that of ufo2fdk,
whose documentation is retained below (and hopefully is still accurate).

Naming Data
~~~~~~~~~~~

As with any OpenType compiler, you have to set the font naming data to a
particular standard for your naming to be set correctly. In ufo2fdk, you
can get away with setting *two* naming attributes in your font.info
object for simple fonts:

-  familyName: The name for your family. For example, "My Garamond".
-  styleName: The style name for this particular font. For example,
   "Display Light Italic"

ufo2fdk will create all of the other naming data based on thse two
fields. If you want to use the fully automatic naming system, all of the
other name attributes should be set to ``None`` in your font. However,
if you want to override the automated system at any level, you can
specify particular naming attributes and ufo2fdk will honor your
settings. You don't have to set *all* of the attributes, just the ones
you don't want to be automated. For example, in the family "My Garamond"
you have eight weights. It would be nice to style map the italics to the
romans for each weight. To do this, in the individual romans and
italics, you need to set the style mapping data. This is done through
the ``styleMapFamilyName`` and ``styleMapStyleName`` attributes. In each
of your roman and italic pairs you would do this:

**My Garamond-Light.ufo**

-  familyName = "My Garamond"
-  styleName = "Light"
-  styleMapFamilyName = "My Garamond Display Light"
-  styleMapStyleName = "regular"

**My Garamond-Light Italic.ufo**

-  familyName = "My Garamond"
-  styleName = "Display Light Italic"
-  styleMapFamilyName = "My Garamond Display Light"
-  styleMapStyleName = "italic"

**My Garamond-Book.ufo**

-  familyName = "My Garamond"
-  styleName = "Book"
-  styleMapFamilyName = "My Garamond Display Book"
-  styleMapStyleName = "regular"

**My Garamond-Book Italic.ufo**

-  familyName = "My Garamond"
-  styleName = "Display Book Italic"
-  styleMapFamilyName = "My Garamond Display Book"
-  styleMapStyleName = "italic"

**etc.**

Additionally, if you have defined any naming data, or any data for that
matter, in table definitions within your font's features that data will
be honored.

Feature generation
~~~~~~~~~~~~~~~~~~

If your font's features do not contain kerning/mark/mkmk features,
ufo2ft will create them based on your font's kerning/anchor data.

In addition to
`Adobe OpenType feature files <http://www.adobe.com/devnet/opentype/afdko/topic_feature_file_syntax.html>`__,
ufo2ft also supports the
`MTI/Monotype format <http://monotype.github.io/OpenType_Table_Source/otl_source.html>`__.
For example, a GPOS table in this format would be stored within the UFO at
``data/com.github.googlei18n.ufo2ft.mtiFeatures/GPOS.mti``.

Fallbacks
~~~~~~~~~

Most of the fallbacks have static values. To see what is set for these,
look at ``fontInfoData.py`` in the source code.

In some cases, the fallback values are dynamically generated from other
data in the info object. These are handled internally with functions.

Merging TTX
~~~~~~~~~~~

If the UFO data directory has a ``com.github.fonttools.ttx`` folder with TTX
files ending with ``.ttx``, these will be merged in the generated font.
The index TTX (generated when using using ``ttx -s``) is not required.

.. |GitHub Actions status| image:: https://github.com/googlefonts/ufo2ft/workflows/Test%20+%20Deploy/badge.svg
.. |PyPI Version| image:: https://img.shields.io/pypi/v/ufo2ft.svg
   :target: https://pypi.org/project/ufo2ft/
.. |Codecov| image:: https://codecov.io/gh/googlefonts/ufo2ft/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/googlefonts/ufo2ft
.. |Gitter Chat| image:: https://badges.gitter.im/fonttools-dev/ufo2ft.svg
   :alt: Join the chat at https://gitter.im/fonttools-dev/ufo2ft
   :target: https://gitter.im/fonttools-dev/ufo2ft?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge

Color fonts
~~~~~~~~~~~

ufo2ft supports building ``COLR`` and ``CPAL`` tables.

If there is ``com.github.googlei18n.ufo2ft.colorPalettes`` key in font lib, and
``com.github.googlei18n.ufo2ft.colorLayerMapping`` key in the font or
in any of the glyphs lib, then ufo2ft will build ``CPAL`` table from the color
palettes, and ``COLR`` table from the color layers.

``colorPalettes`` is a array of palettes, each palette is a array of colors and
each color is a array of floats representing RGBA colors. For example:

.. code:: xml

    <key>com.github.googlei18n.ufo2ft.colorPalettes</key>
    <array>
      <array>
        <array>
          <real>0.26</real>
          <real>0.0</real>
          <real>0.23</real>
          <real>1.0</real>
        </array>
        <array>
          <real>0.86</real>
          <real>0.73</real>
          <real>0.28</real>
          <real>1.0</real>
        </array>
      </array>
    </array>

``colorLayerMapping`` is a array of color layers, each color layer is a array of
layer name and palette color index. It is a per-glyph key, but if present in
the font lib then it will be used for all glyphs that lack it. For example:

.. code:: xml

      <key>com.github.googlei18n.ufo2ft.colorLayerMapping</key>
      <array>
        <array>
          <string>color.1</string>
          <integer>1</integer>
        </array>
        <array>
          <string>color.2</string>
          <integer>0</integer>
        </array>
      </array>

With these this key present, ufo2ft will copy the color layers into individual
glyphs and setup ``COLR`` table.

Alternatively, if the color layers are already separate UFO glyphs, the
``com.github.googlei18n.ufo2ft.colorLayers`` font lib key can be used. It uses
a table keyed by base glyph, and the value is an array of color layers, each
color layer is an array of glyph name and palette color index. For example:

.. code:: xml

    <key>com.github.googlei18n.ufo2ft.colorLayers</key>
    <dict>
      <key>alef-ar</key>
      <array>
        <array>
          <string>alef-ar.color0</string>
          <integer>2</integer>
        </array>
      </array>
      <key>alefHamzaabove-ar</key>
      <array>
        <array>
          <string>alefHamzaabove-ar.color0</string>
          <integer>1</integer>
        </array>
        <array>
          <string>alefHamzaabove-ar.color1</string>
          <integer>2</integer>
        </array>
      </array>
    <dict>

Setup Notes
~~~~~~~~~~~

If you are installing ufo2ft from source, note that the strict dependency versions in `requirements.txt` are
for testing, see `setup.py`'s install_requires and extras_requires for more relaxed dependency requirements.


|PyPI|

ontobio - a python API for working with ontologies and associations
===================================================================

This module provides objects and utility methods for working with
ontologies and associations of entities (genes, variants, etc) to
ontology classes.

The ontologies and associations can either be local files or provided by
remote services (currently the OntoBee SPARQL service for ontologies and
a Monarch or GO Golr service for associations).

Documentation
=============

Documentation is on `readthedocs <https://ontobio.readthedocs.io>`__

Notebooks
=========

See the `Jupyter
Notebooks <http://nbviewer.jupyter.org/github/biolink/ontobio/tree/master/notebooks/>`__
for code examples

Mailing list
============

-  `biolink-api google
   group <https://groups.google.com/forum/#!forum/biolink-api>`__

.. |PyPI| image:: https://img.shields.io/pypi/v/ontobio.svg
   :target: https://pypi.python.org/pypi/ontobio


[![Documentation Status](https://readthedocs.org/projects/pyxtal/badge/?version=latest)](https://pyxtal.readthedocs.io/en/latest/?badge=latest)
[![Test Status](https://github.com/qzhu2017/PyXtal/workflows/tests/badge.svg)](https://github.com/qzhu2017/PyXtal/actions)
[![Download Status](https://img.shields.io/pypi/pyversions/pyxtal)](https://pypi.org/project/pyxtal/)
[![Download Status](https://img.shields.io/pypi/v/pyxtal)](https://pypi.org/project/pyxtal/)
[![Downloads](https://pepy.tech/badge/pyxtal)](https://pepy.tech/project/pyxtal)
[![DOI](https://zenodo.org/badge/128165891.svg)](https://zenodo.org/badge/latestdoi/128165891)
[![Gitter](https://badges.gitter.im/PyXtal/community.svg)](https://gitter.im/PyXtal/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

## Table of content
- [Introduction](#introduction)
- [Quick Start](#quick-start)
- [Current Features](#current-features)
- [Installation](#installation)
- [Citation](#citation)
- [How to contribute?](#how-to-contribute)

## Introduction

PyXtal is an open source Python package which was initiated by [Qiang Zhu](http://qzhu2017.github.io) and Scott Fredericks. The goal of PyXtal is to develop a fundamental library to allow one to design the material structure with a certain symmetry constraint. These structures can exported to various structural formats for further study. See the [documentation](https://pyxtal.readthedocs.io/en/latest/) for more information.

To contribute to this project, please check [How to contribute?](#how-to-contribute).

## Quick Start

- [Atomic crystal](https://nbviewer.jupyter.org/github/qzhu2017/PyXtal/blob/master/examples/tutorials_notebook/01_atomic_crystals.ipynb)
- [Molecular crystal](https://nbviewer.jupyter.org/github/qzhu2017/PyXtal/blob/master/examples/tutorials_notebook/02_molecular_crystals.ipynb)
- [XRD](https://nbviewer.jupyter.org/github/qzhu2017/PyXtal/blob/master/examples/tutorials_notebook/03_pxrd.ipynb)
- [Molecular Packing](https://nbviewer.org/github/qzhu2017/PyXtal/blob/master/examples/tutorials_notebook/05-crystal-packing.ipynb)

## Current Features

- Generation of atomic structures for a given symmetry and stoichiometry (0-3D)
- Generation of molecular crystals (1-3D) with the support of special Wyckoff positions.
- Structure manipulation via subgroup/supergroup symmetry relation
- Geometry optimization from built-in and external optimization methods.
- Internal support of ``cif`` file and many other formats via ``pymatgen`` or ``ASE``.
- Easy access to symmetry information (e.g., Wyckoff, site symmetry and international symbols).
- X-ray diffraction analysis and [its online application](https://vxrd.physics.unlv.edu)

## Installation

To install the code, one just needs to do

```sh
pip install pyxtal
```

or

```sh
pip install --upgrade git+https://github.com/qzhu2017/PyXtal.git@master
```

## Citation

### General PyXtal

Fredericks S, Parrish K, Sayre D, Zhu Q\*(2020)
[PyXtal: a Python Library for Crystal Structure Generation and Symmetry Analysis](https://www.sciencedirect.com/science/article/pii/S0010465520304057).
\[[arXiv link](https://arxiv.org/pdf/1911.11123.pdf)\]

```bib
@article{pyxtal,
title = "PyXtal: A Python library for crystal structure generation and symmetry analysis",
journal = "Computer Physics Communications",
volume = "261",
pages = "107810",
year = "2021",
issn = "0010-4655",
doi = "https://doi.org/10.1016/j.cpc.2020.107810",
url = "http://www.sciencedirect.com/science/article/pii/S0010465520304057",
author = "Scott Fredericks and Kevin Parrish and Dean Sayre and Qiang Zhu",
}
```

### Symmetry relation
Zhu Q, Kang B, Parrish K (2022).
[Symmetry Relation Database and Its Application to Ferroelectric Materials Discovery](https://link.springer.com/article/10.1557/s43579-022-00268-4)

```bib
@article{zhu2022symmetry,
  title="Symmetry relation database and its application to ferroelectric materials discovery",
  author="Zhu, Qiang and Kang, Byungkyun and Parrish, Kevin",
  journal="MRS Communications",
  volume="12",
  number="5",
  pages="686--691",
  year="2022",
  doi="https://doi.org/10.1557/s43579-022-00268-4",
```

### Organic crystal packing motif
Zhu Q, Tang W-L, Hattori S. (2022).
[Quantification of Crystal Packing Similarity from Spherical Harmonic Transform](https://pubs.acs.org/doi/10.1021/acs.cgd.2c00933)

```bib
@article{zhu2022quantification,
  title="Quantification of Crystal Packing Similarity from Spherical Harmonic Transform",
  author="Zhu, Qiang and Tang, Weilun and Hattori, Shinnosuke",
  journal="Crystal Growth \& Design",
  volume="22",
  number="12",
  pages="7308--7316",
  year="2022",
  doi="https://doi.org/10.1021/acs.cgd.2c00933",
}
```

## How to contribute?

This is an open-source project. Its growth depends on the community. To contribute to PyXtal, you don't necessarily have to write the code. Any contributions from the following list will be helpful.

- [![Star on GitHub](https://img.shields.io/github/stars/qzhu2017/pyxtal.svg?style=social)](https://github.com/qzhu2017/pyxtal/stargazers)
 the PyXtal project and recommend it to your colleagues/friends
- Open an [![GitHub issues](https://img.shields.io/github/issues/qzhu2017/pyxtal.svg)](https://GitHub.com/qzhu2017/pyxtal/issues/) to report the bug or address your wishlist or improve our documentation
- [![GitHub forks](https://img.shields.io/github/forks/qzhu2017/pyxtal?style=social)](https://github.com/qzhu2017/PyXtal/network/members) the repository and send us the pull request


# Is this page for you?

[Download the latest Total Replay disk image](https://archive.org/details/TotalReplay) at the archive.org home page if you just want to play hundreds of Apple II games. The rest of this page is for developers who want to work with the source code and assemble it themselves.

# Building the code

## Mac OS X

You will need
 - [Xcode command line tools](https://developer.apple.com/library/archive/technotes/tn2339/_index.html)
 - [ACME](https://sourceforge.net/projects/acme-crossass/)
 - [Parallel](https://www.gnu.org/software/parallel/)
 - [Cadius](https://github.com/mach-kernel/cadius)

As of this writing, all of the non-Xcode programs are installable via [Homebrew](https://brew.sh/).

``` shell
$ brew tap lifepillar/appleii
$ brew install acme parallel mach-kernel-cadius
```

Then open a terminal window and type

``` shell
$ cd 4cade/
$ make
```

If all goes well, the `build/` subdirectory will contain a `4cade.hdv` image which can be mounted in emulators like [OpenEmulator](https://archive.org/details/OpenEmulatorSnapshots), [Ample](https://github.com/ksherlock/ample), or [Virtual II](http://virtualii.com/).

If all does not go well, try doing a clean build (`makeg clean && make`)

If that fails, perhaps you have out-of-date versions of one of the required tools? The [Makefile](https://github.com/a2-4am/4cade/blob/main/Makefile) lists, but does not enforce, the minimum version requirements of each third-party tool.

If that fails, please [file a bug](https://github.com/a2-4am/4cade/issues/new).

## Windows

You will need
 - [ACME](https://sourceforge.net/projects/acme-crossass/)
 - [Cadius for Windows](https://github.com/mach-kernel/cadius)

(Those tools will need to be added to your command-line PATH.)

Then open a `CMD.EXE` window and type

```
C:\> cd 4cade
C:\4cade> winmake dsk
```
If all goes well, the `build\` subdirectory will contain a `4cade.hdv` image which can be mounted in emulators like [AppleWin](https://github.com/AppleWin/AppleWin) or [MAME](http://www.mamedev.org).

If all does not go well, try doing a clean build (`winmake clean`, `winmake dsk`)

If that fails, perhaps you have out-of-date versions of one of the required tools? The [winmake](https://github.com/a2-4am/4cade/blob/main/winmake.bat) lists, but does not enforce, the minimum version requirements of each third-party tool.

If that fails, please [file a bug](https://github.com/a2-4am/4cade/issues/new).

## Linux

You will need
 - [Cadius](https://github.com/mach-kernel/cadius)

Most of the packages are already available pre-compiled and can be installed with the following

``` shell
$ sudo apt-get install git parallel acme
```

To compile Cadius enter the following

``` shell
$ git clone https://github.com/mach-kernel/cadius.git
$ cd cadius
$ make
$ cd bin/release
$ sudo cp cadius /usr/bin
```

Then open a terminal window and type

``` shell
$ git clone https://github.com/a2-4am/4cade.git
$ cd 4cade/
$ make
```

If all goes well, the `build/` subdirectory will contain a `4cade.hdv` image which can be mounted in emulators like [MAME](http://www.mamedev.org).

If all does not go well, try doing a clean build (`make clean && make`)

If that fails, perhaps you have out-of-date versions of one of the required tools? The [Makefile](https://github.com/a2-4am/4cade/blob/main/Makefile) lists, but does not enforce, the minimum version requirements of each third-party tool.

If that fails, please [file a bug](https://github.com/a2-4am/4cade/issues/new).

# Navigating the code

## Initialization

[`4cade.a`](https://github.com/a2-4am/4cade/blob/main/src/4cade.a) is the main assembler target. It builds the launcher itself. Launcher code is split into code that can be run once from main memory then discarded, and code which is relocated to the language card and persists throughout the lifetime of the launcher. As the language card is only 16KB and will also need to store some persistent data structures, memory is precious and tightly managed.

[`4cade.init.a`](https://github.com/a2-4am/4cade/blob/main/src/4cade.init.a) contains the code that is run once at program startup. First, we do some hardware detection, like how much memory you have, whether you have a joystick, and whether you have a IIgs. Then we relocate selected code to the language card and load the appropriate search index. (For example, if you do not have a joystick, games that require a joystick will not appear in search results.) [`constants.a`](https://github.com/a2-4am/4cade/blob/main/src/constants.a) has a rough map of what ends up where, within the language card and its overlapping memory regions. Then we load and parse the global preferences file ([`PREFS.CONF`](https://github.com/a2-4am/4cade/blob/main/res/prefs.conf)) and store the results in the language card. Finally, we jump to the main entry point (`Reenter`). The launcher is initialized; anything left in main memory is discarded.

## Search mode

There are three major modes in the launcher: search mode, browse mode, and mega-attract mode. Search mode is the default, and it is always the first mode you enter when launching the program. [`ui.search.mode.a`](https://github.com/a2-4am/4cade/blob/main/src/ui.search.mode.a) tracks your keystrokes to determine the best match within the game list for the keys you have typed, then loads the game's title screenshot and displays the game name and other information at the bottom of the screen. If you have not yet typed any keys, it displays the title page and welcome message instead. The `InputKeys` table documents all other recognized keys.

The text ranking algorithm is in [`textrank.a`](https://github.com/a2-4am/4cade/blob/main/src/textrank.a). It was inspired by [Quicksilver](https://github.com/quicksilver/Quicksilver) but is an independent implementation.

## Browse mode

The user enters browse mode by pressing the right or down arrow key. [`ui.browse.mode.a`](https://github.com/a2-4am/4cade/blob/main/src/ui.browse.mode.a) then watches for other arrow keys and displays the next or previous game in the game list. The `BrowseKeys` table documents all other recognized keys.

## Mega-Attract mode

If the user presses `Esc` from any other mode, or does not type anything for 30 seconds, the launcher goes into Mega-Attract mode, a.k.a. screensaver mode. [`ui.attract.mode.a`](https://github.com/a2-4am/4cade/blob/main/src/ui.attract.mode.a) manages loading and executing attract mode modules. An attract mode module can be a short slideshow, a self-running demo, or just a single screenshot. Modules are listed in [`ATTRACT.CONF`](https://github.com/a2-4am/4cade/blob/main/res/attract.conf) and are run in order until end-of-file, then it starts over from the beginning. The entire cycle is quite long (several hours), and some screenshots appear in multiple slideshows, but there is no actual randomness in selecting the next attract mode module.

# Navigating the configuration files

## `GAMES.CONF`

[`GAMES.CONF`](https://github.com/a2-4am/4cade/blob/main/res/GAMES.CONF) is the master games list. It contains 1 record for every game in Total Replay. However, not every game is playable on every device, so each record also contains metadata, e.g. "this game requires a joystick," or "this game requires 128K," or "this game has a double hi-res title screen" (which is not identical to "this game requires 128K").

The format of the `GAMES.CONF` file has changed as new requirements have appeared, and it may change again in the future. There is up-to-date format information in comments in the file itself, which I will not duplicate here. However, in general, each record is 1 line and contains the name and flags for 1 game. The file is parsed during build and used to create the search indexes and other files which are stored on the final disk image.

Each game's filename is used as a "foreign key" (in database terms) to build directory paths, to locate files in subdirectories, and to reference the game in other configuration files.

- A game's main executable is always `X/FILENAME/FILENAME`
- A game's HGR title screenshot is always `TITLE.HGR/FILENAME`
- A game's super hi-res box art is always `ARTWORK.SHR/FILENAME` (not all games have artwork)
- A games's help page is always `GAMEHELP/FILENAME` (not all games have help)
- A game's mini-attract mode configuration file is always `ATTRACT/FILENAME`
- Games are included in other attract mode configuration files by `FILENAME`
- The source disk image of a game (in [`res/dsk`](https://github.com/a2-4am/4cade/tree/main/res/dsk)) must have a volume name of `FILENAME`, and there must be a file in the disk image's root directory also named `FILENAME` which is the game's main executable

## `ATTRACT.CONF`

[`ATTRACT.CONF`](https://github.com/a2-4am/4cade/blob/main/res/ATTRACT.CONF) is the master configuration file for Mega-Attract mode. There is up-to-date format information in comments in the file itself, which I will not duplicate here. In general, each record is the name of an attract module, which can be a slideshow, self-running demo, or even a single screenshot. Each attract module corresponds to a file in a separate directory; see format information for details. So the record `FAVORITES2.CONF=1` corresponds to [`a real file`](https://github.com/a2-4am/4cade/blob/main/res/SS/FAVORITES2.CONF) that contains details about that particular hi-res slideshow. `ATTRACT.CONF` and the linked slideshow configuration files are parsed at build time and stored in a custom format on the final disk image.

Attract modules are loosely divided into sets that have a loosely similar mix of hi-res, double hi-res, super hi-res, and self-running demos. The `ATTRACT.CONF` file is maintained by hand and changes frequently as we add games, split up slideshows, or reorder things on a whim.

Since everything is so loosely associated by filename, it is easy to end up with attract modules that aren't listed in `ATTRACT.CONF` (will use disk space but never run), duplicate modules (will loop incorrectly), or modules that refer to non-existent files (will crash and burn). If you make any changes to `ATTRACT.CONF` or any of the files that it references, or any of the files that those files reference, or even sneeze in their general direction, you should run the attract mode consistency check:

``` shell
$ cd 4cade/
$ make attract
```

## `FX.CONF`, `DFX.CONF`

[`FX.CONF`](https://github.com/a2-4am/4cade/blob/main/res/FX.CONF) and its sister [`DFX.CONF`](https://github.com/a2-4am/4cade/blob/main/res/DFX.CONF) list the HGR and DHGR transition effects used in hi-res and double hi-res slideshows. Each record is a filename of a transition effect file, which is an executable file [assembled at build time](https://github.com/a2-4am/4cade/tree/main/src/fx) and stored on final disk image in a custom format. At the beginning of each slideshow, we query the global preferences to find the filename of the FX or DFX file, then update the global preferences with the next filename (wrapping around to the beginning of the list). If you watch the Mega-Attract mode long enough, you will eventually see all the transition effects, and since the cycle of transition effects is separate from the cycle of slideshows, you will eventually see the same slideshow with different transition effects.

These files are parsed at build time and stored on the final disk image in a binary format, then read from disk every time they are needed. Due to memory restrictions, the parsed data is not persisted.

## `PREFS.CONF`

[`PREFS.CONF`](https://github.com/a2-4am/4cade/blob/main/res/PREFS.CONF) contains persistent global state, including Mega-Attract mode state and whether cheats are enabled. There is up-to-date format information in comments in the file itself.

This file is read and parsed once at program startup, and the parsed data is stored persistently in the language card. It is written to disk every time global state changes, which is often during Mega-Attract mode, or if the user toggles cheat mode.

# Compression

Many files in Total Replay are stored in a compressed format, then decompressed at run-time. The compression and decompression is handled by [Exomizer](https://bitbucket.org/magli143/exomizer/wiki/Home), which targets 8-bit platforms. Compressed files include

- [hi-res action screenshots](https://github.com/a2-4am/4cade/tree/main/res/ACTION.HGR)
- [double hi-res action screenshots](https://github.com/a2-4am/4cade/tree/main/res/ACTION.DHGR)
- [super hi-res box art](https://github.com/a2-4am/4cade/tree/main/res/ARTWORK.SHR)

Both the compressed and uncompressed files are stored in the repository, so you do not need Exomizer installed to build Total Replay. You only need it if you add new graphics.

To add a new compressed graphic file, add the uncompressed original file to the appropriate directory ([`ACTION.HGR.UNCOMPRESSED`](https://github.com/a2-4am/4cade/tree/main/res/ACTION.HGR.UNCOMPRESSED), [`ACTION.DHGR.UNCOMPRESSED`](https://github.com/a2-4am/4cade/tree/main/res/ACTION.DHGR.UNCOMPRESSED), or [`ARTWORK.SHR.UNCOMPRESSED`](https://github.com/a2-4am/4cade/tree/main/res/ARTWORK.SHR.UNCOMPRESSED) respectively), then run

``` shell
$ cd 4cade/
$ make compress
```

Then add and commit the compressed files to the repository.


Welcome to POCS documentation!
==============================

[![GHA Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fpanoptes%2FPOCS%2Fbadge%3Fref%3Ddevelop&style=flat)](https://actions-badge.atrox.dev/panoptes/POCS/goto?ref=develop) [![codecov](https://codecov.io/gh/panoptes/POCS/branch/develop/graph/badge.svg)](https://codecov.io/gh/panoptes/POCS) [![Documentation Status](https://readthedocs.org/projects/pocs/badge/?version=latest)](https://pocs.readthedocs.io/en/latest/?badge=latest) [![PyPI version](https://badge.fury.io/py/panoptes-pocs.svg)](https://badge.fury.io/py/panoptes-pocs)

# Project PANOPTES

[PANOPTES](https://www.projectpanoptes.org) is an open source citizen science project
designed to find [transiting exoplanets](https://spaceplace.nasa.gov/transits/en/) with
digital cameras. The goal of PANOPTES is to establish a global network of of robotic
cameras run by amateur astronomers and schools (or anyone!) in order to monitor,
as continuously as possible, a very large number of stars. For more general information
about the project, including the science case and resources for interested individuals, see the
[project overview](https://projectpanoptes.org/articles/).

# POCS

POCS (PANOPTES Observatory Control System) is the main software driver for a
PANOPTES unit, responsible for high-level control of the unit.

For more information, see the full documentation at: https://pocs.readthedocs.io.

## Install

### POCS Environment

If you are running a PANOPTES unit then you will most likely want an  entire PANOPTES environment, which includes the necessary tools for operation of a complete unit.

There is a bash shell script that will install an entire working POCS system on your computer.  Some
folks even report that it works on a Mac.

To install POCS via the script, open a terminal and enter (you may be prompted for your `sudo` password):

```bash
curl -fsSL https://install.projectpanoptes.org > install-pocs.sh
bash install-pocs.sh
```

Or using `wget`:

```bash
wget -qO- https://install.projectpanoptes.org > install-pocs.sh
bash install-pocs.sh
```

The install script will ask a few questions at the beginning of the process. If you are unsure of
the answer the default is probably okay.

In addition to installing `POCS`, the install script will create the Config Server
and Power Monitor services, which will automatically  be restarted upon reboot of the computer.

### POCS Module

If you want just the POCS module, for instance if you want to override it in
your own OCS (see [Huntsman-POCS](https://github.com/AstroHuntsman/huntsman-pocs)
for an example), then install via `pip`:

```bash
pip install panoptes-pocs
```

If you want the extra features, such as Google Cloud Platform connectivity, then
use the extras options:

```bash
pip install "panoptes-pocs[google,focuser,testing]"
```

#### Running POCS

`POCS` requires a few things to properly run:

1. A [`panoptes-utils`](https://github.com/panoptes/panoptes-utils.git) `config-server` running to provide dynamic configuration.
2. An `Observatory` instance that has details about the location of a POCS unit (real or simulated), which hardware is available, etc.

A minimal working example with a simulated `Observatory` would be:

```python
import os
from panoptes.utils.config.server import config_server
from panoptes.pocs.core import POCS

os.environ['PANDIR'] = '/var/panoptes'
conf_server = config_server('conf_files/pocs.yaml')
I 01-20 01:01:10.886 Starting panoptes-config-server with  config_file='conf_files/pocs.yaml'
S 01-20 01:01:10.926 Config server Loaded 17 top-level items
I 01-20 01:01:10.928 Config items saved to flask config-server
I 01-20 01:01:10.934 Starting panoptes config server with localhost:6563

pocs = POCS.from_config(simulators=['all'])
I 01-20 01:01:20.408 Initializing PANOPTES unit - Generic PANOPTES Unit - Mauna Loa Observatory
I 01-20 01:01:20.419 Making a POCS state machine from panoptes
I 01-20 01:01:20.420 Loading state table: panoptes
S 01-20 01:01:20.485 Unit says: Hi there!
W 01-20 01:01:20.494 Scheduler not present
W 01-20 01:01:20.495 Cameras not present
W 01-20 01:01:20.496 Mount not present
I 01-20 01:01:20.497 Scheduler not present, cannot get current observation.

pocs.initialize()
W 01-20 01:01:28.386 Scheduler not present
W 01-20 01:01:28.388 Cameras not present
W 01-20 01:01:28.389 Mount not present
S 01-20 01:01:28.390 Unit says: Looks like we're missing some required hardware.
Out[10]: False
```

For a more realistic usage, see the full documentation at: [https://pocs.readthedocs.io](https://pocs.readthedocs.io).

For actually deploying a PANOPTES unit, refer to the [Operating Guider](https://projectpanoptes.gitbook.io/pocs-user-guide/operation/operating-guides).

#### Developing POCS

See [Coding in PANOPTES](https://github.com/panoptes/POCS/wiki/Coding-in-PANOPTES)

#### [Testing]

To test the software, you can use the standard `pytest` tool from the root of the directory.

By default all tests will be run. If you want to run one specific test, give the specific filename as an argument to `pytest`:

```bash
pytest tests/test_mount.py
```

Links
-----

- PANOPTES Homepage: https://www.projectpanoptes.org
- Forum: https://forum.projectpanoptes.org
- Documentation: https://pocs.readthedocs.io
- Source Code: https://github.com/panoptes/POCS

[Testing]: #testing


# pyuvdata

[![CircleCI](https://circleci.com/gh/RadioAstronomySoftwareGroup/pyuvdata.svg?style=svg&branch=main)](https://circleci.com/gh/RadioAstronomySoftwareGroup/pyuvdata?branch=main)
[![](https://github.com/RadioAstronomySoftwareGroup/pyuvdata/workflows/Run%20Tests/badge.svg?branch=main)](https://github.com/RadioAstronomySoftwareGroup/pyuvdata/actions)
[![codecov](https://codecov.io/gh/RadioAstronomySoftwareGroup/pyuvdata/badge.svg?branch=main)](https://codecov.io/gh/RadioAstronomySoftwareGroup/pyuvdata)
[![DOI](http://joss.theoj.org/papers/10.21105/joss.00140/status.svg)](https://doi.org/10.21105/joss.00140)

pyuvdata defines a pythonic interface to interferometric data sets.
Currently pyuvdata supports reading and writing of miriad, uvfits, CASA measurement sets
and uvh5 files and reading of FHD
([Fast Holographic Deconvolution](https://github.com/EoRImaging/FHD)) visibility save files, SMA Mir files and MWA correlator FITS files.

API documentation and a tutorial is hosted on [ReadTheDocs](https://pyuvdata.readthedocs.io).

# Motivation
The main goals are:

1. To provide a high quality, well documented path to convert between data formats
2. Support the direct use of datasets from python with minimal software
3. Provide precise data definition via both human readable code and high quality online documentation

# Package Details
pyuvdata has four major user classes:

* UVData: supports interferometric data (visibilities) and associated metadata
* UVCal: supports interferometric calibration solutions (antenna-based) and
associated metadata (Note that this is a fairly new object, consider it to be a beta version)
* UVBeam: supports primary beams (E-field or power) and associated metadata
(Note that this is a fairly new object, consider it to be a beta version)
* UVFlag: A class to handle the manipulation and combination of flags for data sets.
Also can convert raw data quality metrics into flags using thresholding.
(This object is very new and experimental. Consider it to be a beta version)

## UVData File standard notes
* miriad has been thoroughly tested with aipy-style miriad files and minimally
tested with ATCA files
* uvfits conforms to AIPS memo 117 (as of March 2020).  It is tested against
FHD, CASA, and AIPS. However AIPS is limited to <80 antennas and CASA uvfits
import does not seem to support >255 antennas. Users with data sets containing > 255
antennas should use the measurement set writer instead.
* CASA measurement sets, primarily conforming to [CASA Memo 229](https://casa.nrao.edu/Memos/229.html), with some elements taken from the proposed v3.0 format documented in [CASA Memo 264](https://casacore.github.io/casacore-notes/264.html). Measurement sets are tested against
VLA and MWA data sets, (the latter filled via cotter), with some manual verification
haven been performed against ALMA and SMA data sets, the latter filled using the `importuvfits` task of CASA.
tested against ALMA-filled datasets and with SMA datasets
* uvh5 is an HDF5-based file format defined by the HERA collaboration,
details in the [uvh5 memo](docs/references/uvh5_memo.pdf). Note that this is a
somewhat new format, so it may evolve a bit
but we will strive to make future versions backwards compatible with the current format.
It is probably not compatible with other interferometric HDF5 files defined by other groups.
* FHD (read-only support, tested against MWA and PAPER data)
* MIR (read-only support, though experimental write functions are available, tested against SMA data)
* MWA correlator FITS files (read-only support, tested against Cotter outputs and FHD)

## UVCal file formats
* calfits: a new format defined in pyuvdata, details in the [calfits_memo](docs/references/calfits_memo.pdf).
Note that this format was recently defined and may change in coming versions,
based on user needs. Consider it to be a beta version, but we will strive to
make future versions backwards compatible with the current format.
* FHD calibration files (read-only support)

## UVBeam file formats
* regularly gridded fits for both E-field and power beams
* non-standard HEALPix fits for both E-field and power beams (in an ImageHDU
rather than a binary table to support frequency, polarization and E-field vector axes)
* read support for CST beam text files, with a defined yaml file format for
metadata, details here: [cst settings file](docs/cst_settings_yaml.rst)

## Under Development
* UVCal: object and calfits file format (beta version)
* UVBeam: object and beamfits file format (beta version)
* UVFlag: object and HDF5 file format. (beta version)
* Mir: object (part of UVData class) (beta version)
* MirParser: object and python interface for MIR file format (beta version)

## Known Issues and Planned Improvements
* UVBeam: support phased-array antenna beams (e.g. MWA beams).
* UVFlag: Adding requires a high level knowledge of individual objects. (see [issue #653](https://github.com/RadioAstronomySoftwareGroup/pyuvdata/issues/653))

For details see the [issue log](https://github.com/RadioAstronomySoftwareGroup/pyuvdata/issues).

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

# Telescopes
pyuvdata has been used with data from the following telescopes. If you use it on
data from a telescope we don't have listed here please let us know how it went
via an issue! We would like to make pyuvdata generally useful to the community for
as many telescopes as possible.

* MWA
* HERA
* PAPER
* LWA
* ALMA
* VLA
* ATCA
* SMA

# Versioning
We use a `generation.major.minor` version number format. We use the `generation`
number for very significant improvements or major rewrites, the `major` number
to indicate substantial package changes (intended to be released every 3-4 months)
and the `minor` number to release smaller incremental updates (intended to be
released approximately monthly and which usually do not include breaking API
changes). 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/pyuvdata/blob/main/CHANGELOG.md).

# History
pyuvdata was originally developed in the low frequency 21cm community to support
the development of and interchange of data between calibration and foreground
subtraction pipelines. Particular focus has been paid to supporting drift and
phased array modes.

# Citation
Please cite pyuvdata by citing our JOSS paper:

Hazelton et al, (2017), pyuvdata: an interface for astronomical interferometeric
datasets in python, Journal of Open Source Software, 2(10), 140, doi:10.21105/joss.00140

[ADS Link](https://ui.adsabs.harvard.edu/abs/2017JOSS....2..140H);
[Bibtex entry](http://adsabs.harvard.edu/cgi-bin/nph-bib_query?bibcode=2017JOSS....2..140H&data_type=BIBTEX&db_key=GEN&nocookieset=1)

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

For simple installation, the latest stable version is available via conda
(preferred: ```conda install -c conda-forge pyuvdata```) or pip (```pip install pyuvdata```).

There are some optional dependencies that are required for specific functionality,
which will not be installed automatically by conda or pip.
See [Dependencies](#dependencies) for details on installing optional dependencies.

## Dependencies

Required:

* astropy >= 6.0
* docstring_parser>=0.15
* h5py >= 3.4
* numpy >= 1.23
* pyerfa >= 2.0.1.1
* python >= 3.10
* pyyaml >= 5.4.1
* scipy >= 1.7.3
* setuptools_scm <7.0|>=7.0.3

Optional:

* astropy-healpix >= 1.0.2 (for working with beams in HEALPix formats)
* astroquery >= 0.4.4 (for enabling phasing to ephemeris objects using JPL-Horizons)
* hdf5plugin >= 3.2.0 (for enabling bitshuffle and other hdf5 compression filters in uvh5 files)
* lunarsky >=0.2.2 (for working with simulated datasets for lunar telescopes)
* novas and novas_de405 (for using the NOVAS library for astrometry)
* python-casacore >= 3.5.2 (for working with CASA measurement sets)

The numpy and astropy versions are important, so make sure these are up to date.

We suggest using conda to install all the dependencies. If you want to install
python-casacore and astropy-healpix, you'll need to add conda-forge as a channel
(```conda config --add channels conda-forge```).

If you do not want to use conda, the packages are also available on PyPI
(python-casacore may require more effort, see details for that package below).
You can install the optional dependencies via pip by specifying an option
when you install pyuvdata, as in ```pip install pyuvdata[healpix]```
which will install all the required packages for using the HEALPix functionality
in pyuvdata. The options that can be passed in this way are:
[`astroquery`, `casa`, `cst`, `hdf5_compression`, `healpix`, `lunar`, `novas`, `all`, `test`,
`doc`, `dev`]. The first set (`astroquery`, `casa`, `cst`, `hdf5_compression`,
`healpix`, `lunar`, `novas`) enable various specific functionality while `all` will install all
optional dependencies. The last three (`test`, `doc`, `dev`) may be useful for developers
of pyuvdata.

### Installing python-casacore
python-casacore requires the casacore c++ libraries. It can be installed easily
using conda (```python-casacore``` on conda-forge).

If you do not want to use conda, the casacore c++ libraries are available for
ubuntu through the [kern suite](http://kernsuite.info/). On OSX, casacore is
available through the [ska-sa brew tap](https://github.com/ska-sa/homebrew-tap).
The python-casacore library (with manual install instructions) is available at
https://github.com/casacore/python-casacore

## Developer Installation
Clone the repository using
```git clone https://github.com/RadioAstronomySoftwareGroup/pyuvdata.git```

Navigate into the pyuvdata directory and run `pip install .`
(note that `python setup.py install` does not work).
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).

To install without dependencies, run `pip install --no-deps .`

To compile the binary extension modules such that you can successfully run
`import pyuvdata` from the top-level directory of your Git checkout, run:
```python setup.py build_ext --inplace```

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

* pytest >= 6.2
* pytest-cases >= 3.8.3
* pytest-cov
* cython >=3.0
* coverage
* pre-commit
* matplotlib
* sphinx
* pypandoc

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 pyuvdata[dev]`) to install the packages needed for testing
(including coverage and linting) and documentation development;
`dev` includes everything in `test` and `doc`.

To use pre-commit to prevent committing code that does not follow our style, you'll
need to run `pre-commit install` in the top level `pyuvdata` directory.

## Tests
Uses the `pytest` package to execute test suite.
From the source pyuvdata directory run ```pytest``` or ```python -m pytest```.

Testing of `UVFlag` module requires the `pytest-cases` plug-in.

# API
The primary interface to data from python is via the UVData object. It provides
import functionality from all supported file formats (UVFITS, Miriad, UVH5, FHD,
CASA measurement sets, SMA Mir, MWA correlator FITS) and export to UVFITS, Miriad,
CASA measurement sets and UVH5 formats and can
be interacted with directly. Similarly, the primary calibration, beam, and flag
interfaces are via the UVCal, UVBeam, and UVflag objects. The attributes of the UVData,
UVCal, UVBeam, and UVFlag objects are described in the UVData Parameters, UVCal Parameters,
UVBeam Parameters and UVFlag Parameters pages on [ReadTheDocs](https://pyuvdata.readthedocs.io).

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

 - Adam Beardsley (Winona State University)
 - Bryna Hazelton (University of Washington)
 - Daniel Jacobs (Arizona State University)
 - Matt Kolopanis (Arizona State University)
 - Paul La Plante (University of Nevada, Las Vegas)
 - 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).

# Acknowledgments

Support for pyuvdata was provided by NSF awards #1835421 and #1835120.


# OpenCTI connectors

[![Website](https://img.shields.io/badge/website-opencti.io-blue.svg)](https://opencti.io)
[![CircleCI](https://circleci.com/gh/OpenCTI-Platform/connectors.svg?style=shield)](https://circleci.com/gh/OpenCTI-Platform/connectors/tree/master)
[![Slack Status](https://img.shields.io/badge/slack-3K%2B%20members-4A154B)](https://community.filigran.io)

The following repository is used to store the OpenCTI connectors for the platform integration with other tools and applications. To know how to enable connectors on OpenCTI, please read the [dedicated documentation](https://docs.opencti.io/latest/deployment/connectors).

## Connectors list and statuses

This repository is used to host connectors that are supported by the core development team of OpenCTI. Nevertheless, the community is also developping a lot of connectors, third-parties modules directly linked to OpenCTI. You can find the list of all available connectors and plugins in the [OpenCTI ecosystem dedicated space](https://filigran.notion.site/OpenCTI-Ecosystem-868329e9fb734fca89692b2ed6087e76).

## Contributing

If you want to help use improve or develop new connector, please check out the **[development documentation for new connectors](https://docs.opencti.io/latest/development/connectors)**. If you want to make your connector available to the community, **please create a Pull Request on this repository**, then we will integrate it to the CI and in the [OpenCTI ecosystem](https://filigran.notion.site/OpenCTI-Ecosystem-868329e9fb734fca89692b2ed6087e76).

## License

**Unless specified otherwise**, connectors are released under the [Apache 2.0](https://github.com/OpenCTI-Platform/connectors/blob/master/LICENSE). If a connector is released by its author under a different license, the subfolder corresponding to it will contain a *LICENSE* file.

## About

OpenCTI is a product designed and developed by the company [Filigran](https://filigran.io).


# FLORIS Wake Modeling and Wind Farm Controls Software

FLORIS is a controls-focused wind farm simulation software incorporating
steady-state engineering wake models into a performance-focused Python
framework. It has been in active development at NREL since 2013 and the latest
release is [FLORIS v4.1](https://github.com/NREL/floris/releases/latest).
Online documentation is available at https://nrel.github.io/floris.

The software is in active development and engagement with the development team
is highly encouraged. If you are interested in using FLORIS to conduct studies
of a wind farm or extending FLORIS to include your own wake model, please join
the conversation in [GitHub Discussions](https://github.com/NREL/floris/discussions/)!

## Installation

**If upgrading from a previous version, it is recommended to install FLORIS v4 into a new virtual environment**.
If you intend to use [pyOptSparse](https://mdolab-pyoptsparse.readthedocs-hosted.com/en/latest/) with FLORIS,
it is recommended to install that package first before installing FLORIS.

FLORIS can be installed by downloading the source code or via the PyPI
package manager with `pip`.

The simplest method is with `pip` by using this command:

```bash
pip install floris
```

Developers and anyone who intends to inspect the source code
can install FLORIS by downloading the git repository
from GitHub with ``git`` and use ``pip`` to locally install it.
It is highly recommended to use a Python virtual environment manager
such as [conda](https://docs.conda.io/en/latest/miniconda.html)
in order to maintain a clean and sandboxed environment. The following
commands in a terminal or shell will download and install FLORIS.

```bash
    # Download the source code from the `main` branch
    git clone -b main https://github.com/NREL/floris.git

    # If using conda, be sure to activate your environment prior to installing
    # conda activate <env name>

    # If using pyOptSpare, install it first
    conda install -c conda-forge pyoptsparse

    # Install FLORIS
    pip install -e floris
```

With both methods, the installation can be verified by opening a Python interpreter
and importing FLORIS:

```python
>>> import floris
>>> help(floris)

Help on package floris:

NAME
    floris - # Copyright 2024 NREL

PACKAGE CONTENTS
    convert_floris_input_v3_to_v4
    convert_turbine_v3_to_v4
    core (package)
    cut_plane
    floris_model
    flow_visualization
    layout_visualization
    logging_manager
    optimization (package)
    parallel_floris_model
    turbine_library (package)
    type_dec
    uncertain_floris_model
    utilities
    version
    wind_data

VERSION
    4.1

FILE
    ~/floris/floris/__init__.py
```

It is important to regularly check for new updates and releases as new
features, improvements, and bug fixes will be issued on an ongoing basis.

## Quick Start

FLORIS is a Python package run on the command line typically by providing
an input file with an initial configuration. It can be installed with
```pip install floris``` (see [installation](https://nrel.github.io/floris/installation.html)).
The typical entry point is
[FlorisModel](https://nrel.github.io/floris/_autosummary/floris.floris_model.html)
which accepts the path to the input file as an argument. From there,
changes can be made to the initial configuration through the
[FlorisModel.set](https://nrel.github.io/floris/_autosummary/floris.floris_model.html#floris.floris_model.FlorisModel.set)
routine, and the simulation is executed with
[FlorisModel.run](https://nrel.github.io/floris/_autosummary/floris.floris_model.html#floris.floris_model.FlorisModel.run).

```python
from floris import FlorisModel
fmodel = FlorisModel("path/to/input.yaml")
fmodel.set(
    wind_directions=[i for i in range(10)],
    wind_speeds=[8.0]*10,
    turbulence_intensities=[0.06]*10
)
fmodel.run()
```

Finally, results can be analyzed via post-processing functions available within
[FlorisModel](https://nrel.github.io/floris/_autosummary/floris.floris_model.html#floris.floris_model.FlorisModel)
such as
- [FlorisModel.get_turbine_layout](https://nrel.github.io/floris/_autosummary/floris.floris_model.html#floris.floris_model.FlorisModel.get_turbine_layout)
- [FlorisModel.get_turbine_powers](https://nrel.github.io/floris/_autosummary/floris.floris_model.html#floris.floris_model.FlorisModel.get_turbine_powers)
- [FlorisModel.get_farm_AEP](https://nrel.github.io/floris/_autosummary/floris.floris_model.html#floris.floris_model.FlorisModel.get_farm_AEP)

and in two visualization packages: [layoutviz](https://nrel.github.io/floris/_autosummary/floris.layout_visualization.html) and [flowviz](https://nrel.github.io/floris/_autosummary/floris.flow_visualization.html).
A collection of examples describing the creation of simulations as well as
analysis and post processing are included in the
[repository](https://github.com/NREL/floris/tree/main/examples). Examples are also listed
in the [online documentation](https://nrel.github.io/floris/examples/001_opening_floris_computing_power.html).

## Engaging on GitHub

FLORIS leverages the following GitHub features to coordinate support and development efforts:

- [Discussions](https://github.com/NREL/floris/discussions): Collaborate to develop ideas for new use cases, features, and software designs, and get support for usage questions
- [Issues](https://github.com/NREL/floris/issues): Report potential bugs and well-developed feature requests
- [Projects](https://github.com/orgs/NREL/projects/96): Include current and future work on a timeline and assign a person to "own" it

Generally, the first entry point for the community will be within one of the
categories in Discussions.
[Ideas](https://github.com/NREL/floris/discussions/categories/ideas) is a great spot to develop the
details for a feature request. [Q&A](https://github.com/NREL/floris/discussions/categories/q-a)
is where to get usage support.
[Show and tell](https://github.com/NREL/floris/discussions/categories/show-and-tell) is a free-form
space to show off the things you are doing with FLORIS.

# License

BSD 3-Clause License

Copyright (c) 2024, Alliance for Sustainable Energy LLC, All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this list of conditions
and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or other materials provided
with the distribution.

* Neither the name of the copyright holder nor the names of its contributors may be used to
endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.


[![License](https://img.shields.io/github/license/plus3it/watchmaker.svg)](./LICENSE)
[![Travis CI Build Status](https://travis-ci.org/plus3it/watchmaker.svg?branch=develop)](https://travis-ci.org/plus3it/watchmaker)
[![Azure DevOps Build Status](https://dev.azure.com/plus3it/watchmaker/_apis/build/status%2Fcontinuous-integration.azure-devops?branchName=main)](https://dev.azure.com/plus3it/watchmaker/_build/latest?definitionId=1&branchName=main)
[![Latest Version](https://img.shields.io/pypi/v/watchmaker.svg?label=version)](https://pypi.python.org/pypi/watchmaker)

# Watchmaker

Applied Configuration Management

## Overview

Watchmaker is a Python package that helps bootstrap a vanilla OS image and
apply an OS configuration. Watchmaker itself reads a simple YAML configuration
file, which can be hosted on the local filesystem or on a web server.

Complex configuration management (CM) environments may be layered in as part of
the provisioning framework. Watchmaker includes a default configuration that
will install Salt and a handful Salt Formulas that can be used to harden a
system to DISA STIG standards, as well as integrate with common enterprise
services.

## Documentation

For more information on installing and using Watchmaker, go to
<https://watchmaker.cloudarmor.io>.


# WMCore
WMCore is a meta project providing multiple software for the CMS Workload Management system, such as WMAgent, ReqMgr2, Global WorkQueue, WMStats and ReqMgr2 MicroServices.
It also provides core libraries to other Data Management and Workload Management (DMWM) CMS services, like CRABServer, DBS3, Tier0, Unified.

## Documentation
General information, as well as development/testing documentation, can be found in our [wiki](https://github.com/dmwm/WMCore/wiki) pages.

## Contributing
For guidance on setting up a development/testing environment and how to contribute to WMCore, please refer to the [CONTRIBUTING](https://github.com/dmwm/WMCore/blob/master/CONTRIBUTING.rst) guidelines.

## Getting Support
For project support and discussions, please join us on our Slack [support](https://cms-dmwm.slack.com/messages/#support) channel; or send an email to our public mailing list cms-oc-dmwm AT cern DOT ch.


This is a monorepo containing the following projects:

* [robotframework-ls](robotframework-ls): RobotFramework Language Server (with VSCode extension).

* [robocorp-code](robocorp-code): Robocorp extension for VSCode.

* [robocorp-python-ls-core](robocorp-python-ls-core): Core components for creating a language server using Python.

* [robotframework-intellij](robotframework-intellij): Support for using the RobotFramework Language Server in Intellij.

* [example-vscode](example-vscode): Example of a VSCode extension making use of [robocorp-python-ls-core](robocorp-python-ls-core).


# Penn Courses
![Workflow](https://github.com/pennlabs/penn-courses/workflows/Workflow/badge.svg)
[![Coverage Status](https://codecov.io/gh/pennlabs/penn-courses/branch/master/graph/badge.svg)](https://codecov.io/gh/pennlabs/penn-courses)

This is the unified home of all [Penn Courses](https://penncourses.org) products.

## Installation & Setup
1. [Install the backend](https://github.com/pennlabs/penn-courses/blob/master/backend/README.md)
2. If you need to, [install the frontend](https://github.com/pennlabs/penn-courses/blob/master/frontend/README.md)

Note that you need the backend to run the frontend.

### Using Dev Containers

This repository has a built-in dev container that you can use to develop the project. To use it, you need to have [Docker](https://www.docker.com/products/docker-desktop) and [VSCode](https://code.visualstudio.com/) installed.

Press the remote container button in the bottom left of the window and select "Reopen in Container". This will build the dev container and open the project in a new window.

This container is designed to work with both backend and frontend development. Some additional steps are required, like installing `pipenv` dependencies and setting up the database and running the frontend server. Please read and follow the instructions in the backend and frontend READMEs.

For more information, visit dev container [documentation](https://code.visualstudio.com/docs/remote/containers).

#### Pushing Code

You can use `ssh-add` to make your SSH keys available to the dev container. This will allow you to push code to GitHub.

```
ssh-add ~/.ssh/id_rsa
```

## API Documentation
API Docs can be found at `/api/documentation` on the back-end server. Also check out the code for more explanations
and documentation! We've tried to keep it up-to-date.

## Runbook
This section is to collect thoughts/learnings from the codebase that have been hard-won, so we don't lose a record of it
if and when the information proves useful again

### Derived fields
Normally, derived fields on models are represented as `@property`-decorated functions. However, there are a few in
the codebase that need to be accessed on the database layer without `JOIN`s. So that they can be indexed.
Specifically, these are the `full_code` fields on `Course` and `Section` models, which are derived from fields on related
models.

These are updated every time the `save()` method is called. However, it's possible to get into a state
(such as with db migrations) where `full_code` isn't set properly.

Open a shell in production, and run this small script:
```python
from tqdm import tqdm
from courses.models import Section, Course

for c in tqdm(Course.objects.all().select_related("department")):
    c.save()

for s in tqdm(Section.objects.all().select_related("course")):
    s.save()
```

`tqdm` will give you a nice progress bar as the script completes. The `select_related` clause speeds up the query,
avoiding what would be a pretty nasty N+1 scenario.


Distributed computing library implemented over PyCOMPSs programming model for HPC.

    Website •
    Documentation •
    Releases •
    Slack

## Introduction

The Distributed Computing Library (dislib) provides distributed algorithms ready to use as a library. So far, dislib is highly focused on machine learning algorithms, and it is greatly inspired by [scikit-learn](https://scikit-learn.org/). However, other types of numerical algorithms might be added in the future. The library has been implemented on top of [PyCOMPSs programming model](http://compss.bsc.es), and it is being developed by the [Workflows and Distributed Computing group](https://github.com/bsc-wdc) of the [Barcelona Supercomputing Center](https://www.bsc.es/). dislib allows easy local development through docker. Once the code is finished, it can be run directly on any distributed platform without any further changes. This includes clusters, supercomputers, clouds, and containerized platforms.

## Contents

- [Introduction](#introduction)
- [Contents](#contents)
- [Quickstart](#quickstart)
- [Availability](#availability)
- [Contributing](#contributing)
- [Citing dislib](#citing-dislib)
  - [Bibtex:](#bibtex)
- [Acknowledgements](#acknowledgements)
- [License](#license)

## Quickstart

Get started with dislib following our [quickstart guide](https://github.com/bsc-wdc/dislib/blob/master/QUICKSTART.md).

## Availability

Currently, the following supercomputers have already PyCOMPSs installed and ready to use. If you need help configuring your own cluster or supercomputer, drop us an email and we will be pleased to help.

- Marenostrum 4 - Barcelona Supercomputing Center (BSC)
- Minotauro - Barcelona Supercomputing Center (BSC)
- Nord 3 - Barcelona Supercomputing Center (BSC)
- Cobi - Barcelona Supercomputing Center (BSC)
- Juron - Jülich Supercomputing Centre (JSC)
- Jureca - Jülich Supercomputing Centre (JSC)
- Ultraviolet - The Genome Analysis Center (TGAC)
- Archer - University of Edinburgh’s Advanced Computing Facility (ACF)
- Axiom - University of Novi Sad, Faculty of Sciences (UNSPMF)

Supported architectures:
- [Intel SSF architectures](https://www.intel.com/content/www/us/en/high-performance-computing/ssf-architecture-specification.html)
- [IBM's Power 9](https://www.ibm.com/it-infrastructure/power/power9-b)

## Contributing

Contributions are **welcome and very much appreciated**. We are also open to starting research collaborations or mentoring if you are interested in or need assistance implementing new algorithms.
Please refer [to our Contribution Guide](CONTRIBUTING.md) for more details.

## Citing dislib

If you use dislib in a scientific publication, we would appreciate you citing the following paper:

J. Álvarez Cid-Fuentes, S. Solà, P. Álvarez, A. Castro-Ginard, and R. M. Badia, "dislib: Large Scale High Performance Machine Learning in Python," in *Proceedings of the 15th International Conference on eScience*, 2019, pp. 96-105

### Bibtex:

```latex
@inproceedings{dislib,
            title       = {{dislib: Large Scale High Performance Machine Learning in Python}},
            author      = {Javier Álvarez Cid-Fuentes and Salvi Solà and Pol Álvarez and Alfred Castro-Ginard and Rosa M. Badia},
            booktitle   = {Proceedings of the 15th International Conference on eScience},
            pages       = {96-105},
            year        = {2019},
 }
```

## Acknowledgements

This work has received funding from the European Union’s Horizon 2020 research and innovation programme under the Marie Skłodowska-Curie grant agreement H2020-MSCA-COFUND-2016-754433.

This work has also received funding from the collaboration project between the Barcelona Supercomputing Center (BSC) and Fujitsu Ltd.

In addition, the development of this software has been also supported by the following institutions:

- Spanish Government under contracts SEV2015-0493, TIN2015-65316 and PID2019-107255G.

- Generalitat de Catalunya under contract 2017-SGR-01414 and the CECH project, co-funded with 50% by the European Regional Development Fund under the
framework of the ERFD Operative Programme for Catalunya 2014-2020.

- European Commission's through the following R&D projects:
  - H2020 I-BiDaaS project (Contract 780787)
  - H2020 BioExcel Center of Excellence (Contracts 823830, and 675728)
  - H2020 EuroHPC Joint Undertaking MEEP Project (Contract 946002)
  - H2020 EuroHPC Joint Undertaking eFlows4HPC Project (Contract 955558)
  - H2020 AI-Sprint project (Contract 101016577)
  - H2020 PerMedCoE  Center of Excellence (Contract 951773)
  - Horizon Europe CAELESTIS project (Contract 101056886)
  - Horizon Europe DT-Geo project (Contract 101058129)

## License

Apache License Version 2.0, see [LICENSE](LICENSE)


[![PyPI version](https://badge.fury.io/py/cogent3.svg)](https://badge.fury.io/py/cogent3)
[![Downloads](https://pepy.tech/badge/cogent3/month)](https://pepy.tech/project/cogent3)

[![Build Status](https://github.com/cogent3/cogent3/workflows/CI/badge.svg?branch=develop)](https://github.com/cogent3/cogent3/actions?workflow=CI)
[![coverall](https://coveralls.io/repos/github/cogent3/cogent3/badge.svg?branch=develop)](https://coveralls.io/github/cogent3/cogent3?branch=develop)

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cogent3)
![Using Black Formatting](https://img.shields.io/badge/code%20style-black-000000.svg)

[![CodeQL](https://github.com/cogent3/cogent3/actions/workflows/codeql.yml/badge.svg)](https://github.com/cogent3/cogent3/actions/workflows/codeql.yml)

`cogent3` is a mature python library for analysis of genomic sequence data. We endeavour to provide a first-class experience within Jupyter notebooks, but the algorithms also support parallel execution on compute systems with 1000's of processors.

## Who is it for?

### Anyone who wants to analyse sequence divergence using robust statistical models

`cogent3` is unique in providing numerous [non-stationary Markov models](http://www.ncbi.nlm.nih.gov/pubmed/25503772) for modelling sequence evolution, [including codon models](https://www.ncbi.nlm.nih.gov/pubmed/28175284). `cogent3` also includes an extensive collection of time-reversible models (again including [novel codon models](https://www.ncbi.nlm.nih.gov/pubmed/19815689)). We have done more than just invent these new methods, we have [established the most robust algorithms](https://www.ncbi.nlm.nih.gov/pubmed/19099591) for their implementation and their [suitability for real data](https://www.ncbi.nlm.nih.gov/pubmed/23935949). Additionally, there are novel signal processing methods focussed on statistical estimation of [integer period signals](https://www.ncbi.nlm.nih.gov/pubmed/21527008).

   🎬 Demo non-reversible substitution model
    <video src="https://user-images.githubusercontent.com/3102996/253845402-f511af2c-c2e2-48bc-8f6e-f9b0f05697e9.mp4" controls="controls" style="max-height:640px">
    </video>

### Anyone who wants to undertake exploratory genomic data analysis

Beyond our novel methods, `cogent3` provides an extensive suite of capabilities for manipulating and analysing sequence data. You can manipulate sequences by their annotations, e.g.

   🎬 Demo sequences with annotations
    <video src="https://user-images.githubusercontent.com/3102996/253847297-2611cda8-e078-4b86-a269-43fbf6ced14c.mp4" controls="controls" style="max-height:640px">
    </video>

Plus, you can read standard tabular and biological data formats, perform multiple sequence alignment using any `cogent3` substitution models, phylogenetic reconstruction and tree manipulation, manipulation of tabular data, visualisation of phylogenies and much more.

### Beginner friendly approach to genomic data analysis

Our `cogent3.app` module provides a very different approach to using the library capabilities. Expertise in structural programming concepts is not essential!

   🎬 Demo friendly coding
    <video src="https://user-images.githubusercontent.com/3102996/253849168-a821de1a-1aad-4761-970f-e365f6b3b1cd.mp4" controls="controls" style="max-height:640px">
    </video>

## Installation?

```bash
$ pip install cogent3
```

### Install `extra` -- adds visualisation support

The `extra` group includes python libraries required for visualisation, i.e. [plotly](https://pypi.org/project/plotly/), [kaleido](https://pypi.org/project/kaleido/), [psutil](https://pypi.org/project/psutil/) and [pandas](https://pypi.org/project/pandas/).

```bash
$ pip install "cogent3[extra]"
```

### Install `dev` -- adds `cogent3` development related libraries

The `dev` group includes python libraries required for development of `cogent3`.

```bash
$ pip install "cogent3[dev]"
```

### Install the development version

```bash
$ pip install git+https://github.com/cogent3/cogent3.git@develop#egg=cogent3
```

## Project Information

`cogent3` is released under the BSD-3 license, documentation is at [cogent3.org](https://cogent3.org), while [`cogent3` code is on GitHub](https://github.com/cogent3/cogent3). If you would like to contribute (and we hope you do!), we have created a companion [`c3dev` GitHub](https://github.com/cogent3/c3dev) repo which provides details on how to contribute and some useful tools for doing so.

## Project History

`cogent3` is a descendant of [PyCogent](https://github.com/pycogent/pycogent.github.com). While there is much in common with PyCogent, the amount of change has been substantial, motivating the name change to `cogent3`. This name has been chosen because `cogent` was always the import name (dating back to [PyEvolve in 2004](https://www.ncbi.nlm.nih.gov/pubmed/14706121)) and it's Python 3 only.

Given this history, we are grateful to the multitude of individuals who have made contributions over the years. Many of these contributors were also co-authors on the original [PyEvolve](https://www.ncbi.nlm.nih.gov/pubmed/14706121) and [PyCogent](https://www.ncbi.nlm.nih.gov/pubmed/17708774) publications. Individual contributions can be seen by using "view git blame" on individual lines of code on GitHub , through git log in the terminal, and more recently the changelog.

Compared to PyCogent version 1.9, there has been a massive amount of changes. These include integration of many of the new developments on algorithms and modelling published by the [Huttley lab](https://biology.anu.edu.au/research/groups/huttley-group-bioinformatics-molecular-evolution-genomes) over the last decade. We have also modernised our dependencies. For example, we now use `plotly` for visualisation, `tqdm` for progress bar display, `concurrent.futures` and `mpi4py.futures` for parallel process execution, `nox` and `pytest` for unit testing.

## Funding

Cogent3 has received funding support from the Australian National University and an [Essential Open Source Software for Science Grant](https://chanzuckerberg.com/eoss/proposals/cogent3-python-apis-for-iq-tree-and-graphbin-via-a-plug-in-architecture/) from the Chan Zuckerberg Initiative.