semvec/pypi-packages huggingface dataset:
techmo-wavelet 0.3.2
A module for audio features extraction from Techmo
Requires Python: >=3.5.0

[![pypi](https://img.shields.io/pypi/v/techmo-wavelet.svg)](https://pypi.org/pypi/techmo-wavelet)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/techmo-wavelet.svg)](https://pypi.org/pypi/techmo-wavelet)
![example workflow](https://github.com/techmo-pl/vamp-wavelet-fft/actions/workflows/python-publish.yml/badge.svg)
## [Techmo Sp. z o.o.](http://techmo.pl) module for audio features extraction

### How to use
:warning: Add `!` character if you install the module in a jupyter notebook
```
pip install techmo-wavelet 

#import functions for feature extraction
from techmo.feature_extraction import calculate_wavelet_fft, calculate_fft_wavelet

# install numpy first in case is not installed in your environment
import numpy as np 

# signal must be 1d array read from wav file, e.x by using Soundfile. Here we generate random signal
signal = np.random.uniform(-1.0, 1.0, 16000)

# Here's an example of how to use `calculate_wavelet_fft` function
features = calculate_wavelet_fft(signal)

# Here's an example of how to use `calculate_fft_wavelet` function
features = calculate_fft_wavelet(signal)

```


### The code implements 2 functions to extract features:

The `calculate_wavelet_fft` function implements an algorithm consisting of the following stages:

1. If the number of samples N is greater than or equal to 4800,
   the signal is divided into int(N/2400) segments to compute finally 60
   features for each segment containing int(N/int(N/2400)) samples,
   i.e. the feature vector will have 60*int(N/2400) elements,
2. Segments are processed by the Hann window,
3. Segments are normalized separately,
4. Each segment is processed by the Wavelet Transform (WT),
5. Each WT subband is subjected to the Fast Fourier Transform (FFT),
6. FFT spectra are inputs of the triangular filtration to obtain
  the feature sub-vectors of length 60 for each segment,
7. The logarithms of filter outputs are computed to obtain
   the feature sub-vectors of length 60 for each segment.
8. Sub-vectors are concatenated to obtain a final feature matrix as numpy ndarray
   of shape int(N/2400), 60.


The `calculate_fft_wavelet` function implements an algorithm consisting of the following stages:

1. If the number of samples N is greater than or equal to 9600,
   the signal is divided into int(N/4800) segments to compute finally 60
   features for each segment containing int(N/int(N/4800)) samples,
   i.e. the feature vector will have 60*int(N/4800) elements,
2. Segments are processed by the Hann window,
3. Segments are normalized separately,
4. Speech segments are processed by the the Fast Fourier Transform,
5. The complex spectra are subjected to Wavelet Transform (WT),
6. Absolute values of WT are calculated,
7. The computed modules are inputs of the triangular filtration,
8. The logarithms of filter outputs are computed to obtain
   the feature sub-vectors of length 60 for each segment.
9. Sub-vectors are concatenated to obtain a final feature matrix
   as numpy ndarray of shape int(N/4800), 60.
django-courriers 0.9.1
A generic application to manage your newsletters

django-courriers
================

.. image:: https://secure.travis-ci.org/ulule/django-courriers.png?branch=master
    :alt: Build Status
    :target: http://travis-ci.org/ulule/django-courriers

A generic application to manage your newsletters

What it does?
-------------

django-courriers has three models:

- ``NewsletterList`` which represents a newsletter list
- ``Newsletter`` which represents a newsletter
- ``NewsletterItem`` an item of a newsletter. It could be a content-type
- ``NewsletterSubscriber`` which represents a user who is subscribed to a newsletter


You have the choice between three backends to manage and send your emails:

- ``SimpleBackend``, a simple backend to send emails with Django and
  your current smtp configuration
- ``MailJetBackend``, a `Mailjet`_ backend which uses `mailjet library`_


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

1. Download the package on GitHub_ or simply install it via PyPi
2. Add ``courriers`` to your ``INSTALLED_APPS`` ::

    INSTALLED_APPS = (
        'courriers',
    )

3. Sync your database using ``syncdb`` command from django command line
4. Configure settings

You have to specify which backend you want to use in your settings ::

    COURRIERS_BACKEND_CLASS = 'courriers.backends.simple.SimpleBackend'

A quick reminder: you can also set your custom ``DEFAULT_FROM_EMAIL`` in Django settings.

Backends
--------

courriers.backends.simple.SimpleBackend
........................................

A simple backend to send your emails with Django and
your current smtp configuration

courriers.backends.mailjet.MailjetBackend
..............................................

A backend to manage your newsletters with Mailjet.


What you need to do for mailjet
.................................

- Create an account on Mailjet
- Get your API key and API Secret key
- Add it to your settings with others options as described below
- Install the `mailjet library`_
- Create a list or more if you have users
  from different countries

With this backend you have to provide additional settings ::

    COURRIERS_MAILJET_API_KEY = 'Your API key'
    COURRIERS_MAILJET_API_SECRET_KEY = 'Your API Secret key'
    COURRIERS_DEFAULT_FROM_NAME = 'Your name'

.. _GitHub: https://github.com/ulule/django-courriers
.. _Mailjet: https://eu.mailjet.com/
.. _mailjet library: https://pypi.python.org/pypi/mailjet/
calsi 0.0.2
To perform calculator actions
Requires Python: >=3.9.5

Contains long discription about software
MIT License

Copyright (c) 2021 xyz

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
musdl 3.1.8
[mus]escore [d]own[l]oader, ported from TypeScript
Requires Python: >=3.6

# musdl

![logo](https://raw.githubusercontent.com/ongyx/musdl/master/logo.jpg "musdl")

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/musdl)](https://pypi.org/project/musdl)
![PyPI - License](https://img.shields.io/pypi/l/musdl)
![PyPI](https://img.shields.io/pypi/v/musdl)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/musdl)
![Lines of code](https://img.shields.io/tokei/lines/github/ongyx/musdl)

## NOTE

**The author of musdl does NOT condone piracy in any way, and is not responsible for anything that happens as a result of piracy arising from the use of musdl.**

musdl (**mus**score **d**own**l**oader) is a downloader for Musescore, written in Python.

The easiest way to download the score is through the CLI:

```text
musdl (musescore url)
```

To convert to another format, use `-f/--format`:

```text
# export as midi
musdl -f mid (musescore url)
```

For a complete list of formats, run `musdl --help`.
If you want to export in any format besides `mscz`, you need to [install](#install) musescore first.

It can also be imported and used as a module:

```python
from musdl import Score, OnlineScore

my_score = OnlineScore("musescore_url")

# Read the score's metadata,
name = my_score["workTitle"]
# or save the whole score...
my_score.export("mscz", "my_score.mscz")

# ...and then load it again.
my_score = Score.from_file("my_score.mscz")
```

For API documentation, see [here](API.md).

## How it works

I just copied over the IPNS-specific constants and used them to download the score file from [Xmader](https://github.com/Xmader)'s [dataset](https://github.com/Xmader/musescore-dataset).

Other approaches were considered:

- Create a native Python interpreter just to decode the musescore js (like Js2py). (Will problably break with every API change.)
- Use a headless JS browser with Selenium. (Resource-heavy, not really cross-platform.)
- Run a JS engine like PyMiniRacer/PyQt5. (Better speed, but needs C extensions.)

So I decided to roll with the IPNS dataset.

## takedown request, et tu

Take a look at this [issue](https://github.com/Xmader/musescore-downloader/issues/5) in the same repo.

## Hacking

All my python projects now use [flit](https://pypi.org/project/flit) to build and publish.
So you need to `python3 -m pip install flit` first.

```text
flit build
```

## Install

`(python3 -m) pip install musdl`

Optionally, to export the score in other formats (midi, mp3, etc.) install musescore.
musdl relies on its command-line tool `mscore` to export scores:

```text
# Linux
sudo (package manager/snap) install musescore
# Windows
scoop bucket add extras  # add the extras bucket if you haven't
scoop install musescore
```

## License

MIT.