semvec/pypi-packages huggingface dataset:
qfp 0.2.0
Quad-based audio fingerprinting (fork of https://github.com/mbortnyck/qfp)
Requires Python: >=3.8,<3.11
Keywords: audio,fingerprinting

# Qfp
Qfp is a python library for creating audio fingerprints that are robust to alterations in pitch and speed. This method is ideal for ID'ing music from recordings such as DJ sets where the tracks are commonly played at a different pitch or speed than the original recording. Qfp is an implementation of the audio fingerprinting/recognition algorithms detailed in a 2016 academic paper by Reinhard Sonnleitner and Gerhard Widmer [[1]](http://www.cp.jku.at/research/papers/Sonnleitner_etal_DAFx_2014.pdf).

**NOTE**: This is a fork of https://github.com/mbortnyck/qfp/ which incorporates:
* multiple bug fixes
* Python 3 compatibilty
* modern packaging with Poetry

This is all in service of having a convient audio fingerprinting service
for a website I'm working on.
---

## Quickstart
Install by downloading it from PyPI.

```bash
pip install qfp
```

You can create a fingerprint from your reference audio...

```python
from qfp import ReferenceFingerprint

fp_r = ReferenceFingerprint("Prince_-_Kiss.mp3")
fp_r.create()
```

...or a query fingerprint from an audio clip that you wish to identify.

```python
from qfp import QueryFingerprint

fp_q = QueryFingerprint("unknown_audio.wav")
fp_q.create()
```

The QfpDB can store reference fingerprints...
```python
from qfp.db import QfpDB

db = QfpDB()
db.store(fp_r, "Prince - Kiss")
```

... and look up query fingerprints.
```python
fp_q = QueryFingerprint("kiss_pitched_up.mp3")
fp_q.create()
db.query(fp_q)
print(fp_q.matches)
```
```python
[Match(record=u'Prince - Kiss', offset=0, vScore=0.7077922077922078)]
```


Qfp currently accepts recordings in [any format that FFmpeg can handle](http://www.ffmpeg.org/general.html#File-Formats).

## Dependencies

FFmpeg - [https://github.com/FFmpeg/FFmpeg](https://github.com/FFmpeg/FFmpeg)<br>
NumPy - [https://github.com/numpy/numpy](https://github.com/numpy/numpy)<br>
Pydub - [https://github.com/jiaaro/pydub](https://github.com/jiaaro/pydub)<br>
SciPy - [https://github.com/scipy/scipy](https://github.com/scipy/scipy)<br>
SQLite - [https://www.sqlite.org/](https://www.sqlite.org/)<br>

***
*<sub>[1]	R. Sonnleitner and G. Widmer, "Robust quad-based audio fingerprinting," IEEE/ACM Transactions on Audio, Speech and Language Processing (TASLP), vol. 24, no. 3, pp. 409–421, Jan. 2016. [Online]. Available: [http://ieeexplore.ieee.org/abstract/document/7358094/](http://ieeexplore.ieee.org/abstract/document/7358094/). Accessed: Nov. 15, 2016.<sub>*
django4-cron 0.5.1
Running python crons in a Django project. Updated to work with Django 4.0 by Rehmat Alam.
Keywords: django django 4 cron

===========
Deprecated
===========
Please use https://github.com/iMerica/dj-rest-auth as this project is no longer maintained. Thanks!

===========
django-cron
===========

.. image:: https://travis-ci.org/Tivix/django-cron.png
    :target: https://travis-ci.org/Tivix/django-cron


.. image:: https://coveralls.io/repos/Tivix/django-cron/badge.png
    :target: https://coveralls.io/r/Tivix/django-cron?branch=master


.. image:: https://readthedocs.org/projects/django-cron/badge/?version=latest
    :target: https://readthedocs.org/projects/django-cron/?badge=latest

Django-cron lets you run Django/Python code on a recurring basis providing basic plumbing to track and execute tasks. The 2 most common ways in which most people go about this is either writing custom python scripts or a management command per cron (leads to too many management commands!). Along with that some mechanism to track success, failure etc. is also usually necesary.

This app solves both issues to a reasonable extent. This is by no means a replacement for queues like Celery ( http://celeryproject.org/ ) etc.


Documentation
=============
http://django-cron.readthedocs.org/en/latest/

This open-source app is brought to you by Tivix, Inc. ( http://tivix.com/ )
pytorch-ckpt-manager 0.1.3
A simple PyTorch checkpoint manager
Requires Python: >=3.7

# PyTorch Checkpoint Manager

A custom PyTorch checkpoint manager inspired by [TensorFlow's CheckpointManager](!https://www.tensorflow.org/api_docs/python/tf/train/CheckpointManager). Specify the necessary arguments in the constructor and then use the `CheckpointManager.save()` and `CheckpointManager.load()` methods to save/load models. Functionality is similar to that of `torch.save()` and `torch.load()`.

# Example usage

The following is a simple convolutional network for demonstrating the checkpoint manager's functionality.

Imports:
```py
# Neural network source: https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_a_general_checkpoint.html

import torch
import torch.nn as nn
from ckpt_manager import CheckpointManager
```

Create the neural network and its optimizer:
```py
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
```

Create the CheckpointManager:
```py
manager = CheckpointManager(
    assets={
        'model' : net.state_dict(),
        'optimizer' : optimizer.state_dict()
    },
    directory='training_checkpoints',
    file_name='model',
    maximum=3,
    file_format='pt'
)
```

Save the states to the directory specified in the constructor:
```py
manager.save()
```

Load the states from the directory:
```py
load_data = manager.load()

net.load_state_dict(load_data['model'])
optimizer.load_state_dict(load_data['optimizer'])
```

If there is nothing to load, `net` and `optimizer` won't be altered.