Commit 2b637e8a authored by Florent Jaillet's avatar Florent Jaillet

Initial commit

parents
FROM ubuntu:16.04
MAINTAINER Florent Jaillet
WORKDIR /tmp/
RUN apt-get update && \
apt-get upgrade -y && \
apt-get install -y --no-install-recommends \
wget \
ca-certificates \
bzip2 \
gcc \
g++ \
git \
&& \
apt-get clean
ENV CONDA=/miniconda/bin/conda
RUN wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
bash Miniconda3-latest-Linux-x86_64.sh -b -p /miniconda && \
rm Miniconda3-latest-Linux-x86_64.sh && \
$CONDA update -n base -y conda && \
$CONDA update -y --all && \
$CONDA install -y conda-build anaconda-client && \
$CONDA clean -y --all
RUN mkdir -p /root/.config/matplotlib && \
echo "backend: pdf" > /root/.config/matplotlib/matplotlibrc
Conda recipes for skmad-suite
=============================
This repository provides conda recipes for the skmad-suite packages and some of
their dependencies.
The recipes are available in the directory [recipes](recipes) and can be
used to build conda packages for Linux and macOS. The resulting packages
are released through the [skmad channel](https://anaconda.org/skmad) on
anaconda.org.
The directory [docker](docker) contains a Dockerfile that can be used to create
a Linux Docker image suitable for the generation of the conda packages for
Linux.
The resulting Docker image is available via the registry of this GitLab
project. You can run it with:
```bash
docker run -it registry.gitlab.lis-lab.fr:5005/skmad-suite/conda_recipes/ubuntu:16.04
```
Building the Docker image for Linux
-----------------------------------
If needed, you can build the Docker image with:
```bash
docker build -t conda_builder docker
```
You can then run this image in interactive mode to build the conda packages
with:
```bash
docker run -it conda_builder
```
Building and uploading the conda packages
-----------------------------------------
To build the conda packages, you need to install the conda package manager,
the simplest solution for this being to install
[miniconda](https://conda.io/miniconda.html).
In your conda environment, if not already installed, install the `conda-build`
and `anaconda-client` packages:
```bash
conda install conda-build anaconda-client
```
Clone the conda_recipes repository:
```bash
git clone https://gitlab.lis-lab.fr/skmad-suite/conda_recipes.git
```
Use conda to build the package of your choice. See the readme.md file in
the diretory containing the recipe that you want to build for detailed
build and upload instructions.
python_version:
- 2.7
- 3.5
- 3.6
- 3.7
{% set name = "ltfatpy" %}
{% set version = "1.0.15" %}
{% set file_ext = "tar.gz" %}
{% set hash_type = "sha256" %}
{% set hash_value = "f89f1e272251c3cc0acbdab26d6e627351b412c0c9645df7a221a94e26496e6c" %}
package:
name: '{{ name|lower }}'
version: '{{ version }}'
source:
fn: '{{ name }}-{{ version }}.{{ file_ext }}'
url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.{{ file_ext }}
'{{ hash_type }}': '{{ hash_value }}'
build:
number: 0
script: python setup.py install --single-version-externally-managed --record=record.txt
requirements:
host:
- nomkl
- cmake
- make
- fftw
- openblas
- lapack
- cython
- python {{ python_version }}
- setuptools
- scipy >=0.18
- numpy >=1.8
- matplotlib >=1.4
- six >=1.10
run:
- nomkl
- fftw
- openblas
- python
- scipy >=0.18
- numpy >=1.8
- matplotlib >=1.4
- six >=1.10
test:
requires:
- pytest
commands:
- pytest --pyargs ltfatpy
about:
home: https://gitlab.lis-lab.fr/dev/ltfatpy
license: GPL-3.0
license_family: GPL3
license_file: LICENSE.rst
summary: The Large Time-Frequency Toolbox (LTFAT) in Python
description: |
The **ltfatpy** package is a partial Python port of the
[Large Time/Frequency Analysis Toolbox (LTFAT)](http://ltfat.sourceforge.net),
a MATLAB©/Octave toolbox for working with time-frequency analysis and
synthesis.
It is intended both as an educational and a computational tool.
The package provides a large number of linear transforms including Gabor
transforms along with routines for constructing windows (filter
prototypes) and routines for manipulating coefficients.
The original LTFAT Toolbox for MATLAB©/Octave is developed at
[CAHR](http://www.dtu.dk/centre/cahr/English.aspx), Technical University
of Denmark, [ARI](http://www.kfs.oeaw.ac.at), Austrian Academy of
Sciences and [I2M](http://www.i2m.univ-amu.fr), Aix-Marseille
Université.
The Python port is developed at
[LabEx Archimède](http://labex-archimede.univ-amu.fr), as a
[LIF](http://www.lif.univ-mrs.fr/) (now [LIS](http://www.lis-lab.fr/)) and
I2M project, Aix-Marseille Université.
This package, as well as the original LTFAT toolbox, is Free software,
released under the GNU General Public License (GPLv3).
doc_url: http://dev.pages.lis-lab.fr/ltfatpy
dev_url: https://gitlab.lis-lab.fr/dev/ltfatpy
extra:
recipe-maintainers: Florent Jaillet <contact.dev@lis-lab.fr>
Building and uploading the ltfatpy conda package
------------------------------------------------
To build the package, from the current directory, run:
```bash
conda build -c anaconda -c conda-forge .
```
Note: In the previous command, we specify the channel `conda-forge`
because the `ltfatpy` package requires packages that are not available in
Anaconda but are provided by the channel `conda-forge`.
We also specify `anaconda` as the first channel, because we want to
preferentially use packages from Anaconda for packages that are both available
in Anaconda and conda-forge.
Once built, a package can be uploaded to anaconda.org using the Anaconda
client:
```bash
anaconda upload --user ltfatpy /miniconda/conda-bld/linux-64/ltfatpy*
```
Note: in the previous command the path of the uploaded file should be adapted
according to the installation directory of your conda distribution and the
architecture for which the package has been built.
{% set name = "madarrays" %}
{% set version = "1.1.2" %}
{% set file_ext = "tar.gz" %}
{% set hash_type = "sha256" %}
{% set hash_value = "3f3e7f91e856a4ee1447503aaab0920a1befb7e0d7246c06ccff942bcf2b36c6" %}
package:
name: '{{ name|lower }}'
version: '{{ version }}'
source:
fn: '{{ name }}-{{ version }}.{{ file_ext }}'
url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.{{ file_ext }}
'{{ hash_type }}': '{{ hash_value }}'
build:
noarch: python
number: 0
script: python setup.py install --single-version-externally-managed --record=record.txt
requirements:
host:
- python >=3.5
- setuptools
- matplotlib >=2.1
- numpy >=1.13
- scipy >=0.19
- simpleaudio >=1.0
- resampy >=0.2
run:
- python >=3.5
- matplotlib >=2.1
- numpy >=1.13
- scipy >=0.19
- simpleaudio >=1.0
- resampy >=0.2
test:
requires:
- ipython
- pytest
commands:
- pytest --pyargs madarrays
about:
home: https://gitlab.lis-lab.fr/skmad-suite/madarrays
license: GPL-3.0
license_family: GPL3
license_file: LICENSE.txt
summary: Python package for audio data structures with missing entries
description: |
MadArrays is a Python package that regroups various data structures adapted
to handle audio signals with missing data.
doc_url: 'http://skmad-suite.pages.lis-lab.fr/madarrays'
dev_url: 'https://gitlab.lis-lab.fr/skmad-suite/madarrays'
extra:
recipe-maintainers: Florent Jaillet <contact.dev@lis-lab.fr>
Building and uploading the madarrays conda package
--------------------------------------------------
To build the package, from the current directory, run:
```bash
conda build -c anaconda -c conda-forge -c skmad .
```
Note: In the previous command, we specify the channel `conda-forge` and `skmad`
because the `madarrays` package requires packages that are not available in
Anaconda but are provided by the channel `conda-forge` and `skmad`.
We also specify `anaconda` as the first channel, because we want to
preferentially use packages from Anaconda for packages that are both available
in Anaconda and conda-forge.
Once built, a package can be uploaded to anaconda.org using the Anaconda
client:
```bash
anaconda upload --user skmad /miniconda/conda-bld/noarch/madarrays*
```
Note: in the previous command the path of the uploaded file should be adapted
according to the installation directory of your conda distribution.
{% set name = "pyteuf" %}
{% set version = "1.0.1" %}
{% set file_ext = "tar.gz" %}
{% set hash_type = "sha256" %}
{% set hash_value = "b0e0ec3d7b385f1e66dbafca620c5500e4cf244c82db1ce4b3a518caa5315b8a" %}
package:
name: '{{ name|lower }}'
version: '{{ version }}'
source:
fn: '{{ name }}-{{ version }}.{{ file_ext }}'
url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.{{ file_ext }}
'{{ hash_type }}': '{{ hash_value }}'
build:
noarch: python
number: 0
script: python setup.py install --single-version-externally-managed --record=record.txt
requirements:
host:
- python >=3.5
- setuptools
- ltfatpy >=1.0.15
- madarrays >=1.1
- matplotlib >=2.1
- numpy >=1.13
run:
- python >=3.5
- ltfatpy >=1.0.15
- madarrays >=1.1
- matplotlib >=2.1
- numpy >=1.13
test:
requires:
- pytest
commands:
- pytest --pyargs pyteuf
about:
home: https://gitlab.lis-lab.fr/skmad-suite/pyteuf
license: GPL-3.0
license_family: GPL3
license_file: LICENSE.txt
summary: Python package for time-frequency analysis
description: |
pyteuf is a package for time-frequency analysis/synthesis with possibly
missing data in Python.
doc_url: 'http://skmad-suite.pages.lis-lab.fr/pyteuf'
dev_url: 'https://gitlab.lis-lab.fr/skmad-suite/pyteuf'
extra:
recipe-maintainers: Florent Jaillet <contact.dev@lis-lab.fr>
Building and uploading the pyteuf conda package
-----------------------------------------------
To build the package, from the current directory, run:
```bash
conda build -c anaconda -c conda-forge -c skmad -c ltfatpy .
```
Note: In the previous command, we specify the channel `conda-forge`, `skmad`
and `ltfatpy` because the `pyteuf` package requires packages that are not
available in Anaconda but are provided by the channel `conda-forge`, `skmad`
and `ltfatpy`.
We also specify `anaconda` as the first channel, because we want to
preferentially use packages from Anaconda for packages that are both available
in Anaconda and conda-forge.
Once built, a package can be uploaded to anaconda.org using the Anaconda
client:
```bash
anaconda upload --user skmad /miniconda/conda-bld/noarch/pyteuf*
```
Note: in the previous command the path of the uploaded file should be adapted
according to the installation directory of your conda distribution.
python_version:
- 3.5
- 3.6
- 3.7
{% set name = "simpleaudio" %}
{% set version = "1.0.2" %}
{% set file_ext = "tar.gz" %}
{% set hash_type = "sha256" %}
{% set hash_value = "4e0e4c0359f153408e9b8a65342ec0c1d014f36fbe9cdb594e9b6e5348916af8" %}
package:
name: '{{ name|lower }}'
version: '{{ version }}'
source:
fn: '{{ name }}-{{ version }}.{{ file_ext }}'
url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.{{ file_ext }}
'{{ hash_type }}': '{{ hash_value }}'
build:
number: 0
script: |
export C_INCLUDE_PATH=$PREFIX/include/
python setup.py install --single-version-externally-managed --record=record.txt
requirements:
host:
- alsa-lib [linux]
- python {{ python_version }}
- setuptools
run:
- alsa-lib [linux]
- python
test:
imports:
- simpleaudio
about:
home: https://github.com/hamiltron/py-simple-audio
license: MIT License
license_family: MIT
license_file: ''
summary: Simple, asynchronous audio playback for Python 3.
description: |
The simplaudio package provides cross-platform, dependency-free audio
playback capability for Python 3 on OSX, Windows, and Linux.
doc_url: http://simpleaudio.readthedocs.io
dev_url: https://github.com/hamiltron/py-simple-audio
extra:
recipe-maintainers: Florent Jaillet <contact.dev@lis-lab.fr>
Building and uploading the simpleaudio conda package
----------------------------------------------------
To build the package, from the current directory, run:
```bash
conda build -c anaconda -c conda-forge .
```
Note: In the previous command, we specify the channel `conda-forge`
because the `simpleaudio` package requires packages that are not available in
Anaconda but are provided by the channel `conda-forge`.
We also specify `anaconda` as the first channel, because we want to
preferentially use packages from Anaconda for packages that are both available
in Anaconda and conda-forge.
Once built, a package can be uploaded to anaconda.org using the Anaconda
client:
```bash
anaconda upload --user skmad /miniconda/conda-bld/linux-64/simpleaudio*
```
Note: in the previous command the path of the uploaded file should be adapted
according to the installation directory of your conda distribution and the
architecture for which the package has been built.
{% set name = "yafe" %}
{% set version = "1.0.2" %}
{% set file_ext = "tar.gz" %}
{% set hash_type = "sha256" %}
{% set hash_value = "6dccb1026113a6bb330e19656f6cad11004fa1f8ccf1de1e0fb89bb91aa3ae64" %}
package:
name: '{{ name|lower }}'
version: '{{ version }}'
source:
fn: '{{ name }}-{{ version }}.{{ file_ext }}'
url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.{{ file_ext }}
'{{ hash_type }}': '{{ hash_value }}'
build:
noarch: python
number: 0
script: python setup.py install --single-version-externally-managed --record=record.txt
requirements:
host:
- python >=3.5
- setuptools
- numpy >=1.13
run:
- python >=3.5
- numpy >=1.13
test:
requires:
- pytest
commands:
- pytest --pyargs yafe
about:
home: https://gitlab.lis-lab.fr/skmad-suite/yafe
license: GPL-3.0
license_family: GPL3
license_file: LICENSE.txt
summary: Yet Another Framework for Experiments
description: |
A classical workflow consists in the following steps:
- load some data,
- generate a problem from the data,
- solve the problem,
- compute performance criteria,
- display results.
Experiments are then conducted by repeating this task while varying the
data, problem parameters, solvers and/or solver parameters. A computer
cluster may be used to run all the resulting tasks in parallel, which
requires to distribute them adequately among the available resources and
then to collect and merge the results.
The package yafe offers a generic framework to conduct such experiments,
aiming at saving time and avoiding errors:
- the generic framework facilitates the design of experiments,
- convenient data structures help to handle results quickly and without
confusion between multiple dimensions,
- intermediate results can be tracked,
- tasks are computed once, even when new tasks are added.
doc_url: 'http://skmad-suite.pages.lis-lab.fr/yafe'
dev_url: 'https://gitlab.lis-lab.fr/skmad-suite/yafe'
extra:
recipe-maintainers: Florent Jaillet <contact.dev@lis-lab.fr>
Building and uploading the yafe conda package
---------------------------------------------
To build the package, from the current directory, run:
```bash
conda build .
```
Once built, a package can be uploaded to anaconda.org using the Anaconda
client:
```bash
anaconda upload --user skmad /miniconda/conda-bld/noarch/yafe*
```
Note: in the previous command the path of the uploaded file should be adapted
according to the installation directory of your conda distribution.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment