semvec/pypi-packages huggingface dataset:
soundstream 0.0.1
Implementation of SoundStream, an end-to-end neural audio codec
License: MIT
Requires Python: >=3.10,<4.0

# SoundStream - PyTorch
Implementation of [SoundStream](https://arxiv.org/abs/2107.03312), an end-to-end neural audio codec

![Figure 2 from the SoundStream paper](images/figure2.png)

- 🔊 Implements SoundStream model inference
- 🎛️ Works with 27M parameter [model](https://huggingface.co/haydenshively/SoundStream/) pretrained on 10k hours of English speech ([Multilingual LibriSpeech](https://www.openslr.org/94/) dataset)

## Install
```bash
pip install soundstream
```

## Usage

> **Note**
> The pretrained model is configured as specified in [NaturalSpeech 2](https://arxiv.org/abs/2304.09116), so it has different channels/strides than the original SoundStream.

```Python
import torchaudio

from soundstream import from_pretrained, load


waveform = load('in.wav')
audio_codec = from_pretrained()  # downloads model from Hugging Face

quantized = audio_codec(waveform, mode='encode')
recovered = audio_codec(quantized, mode='decode')

torchaudio.save('out.wav', recovered[0], 16000)
```

## Citations

### Code

- https://github.com/descriptinc/melgan-neurips
- https://github.com/lucidrains/audiolm-pytorch
- https://github.com/wesbz/SoundStream

### Papers

```bibtex
@misc{zeghidour2021soundstream,
      title={SoundStream: An End-to-End Neural Audio Codec}, 
      author={Neil Zeghidour and Alejandro Luebs and Ahmed Omran and Jan Skoglund and Marco Tagliasacchi},
      year={2021},
      eprint={2107.03312},
      archivePrefix={arXiv},
      primaryClass={cs.SD}
}
```

```bibtex
@misc{kumar2019melgan,
      title={MelGAN: Generative Adversarial Networks for Conditional Waveform Synthesis}, 
      author={Kundan Kumar and Rithesh Kumar and Thibault de Boissiere and Lucas Gestin and Wei Zhen Teoh and Jose Sotelo and Alexandre de Brebisson and Yoshua Bengio and Aaron Courville},
      year={2019},
      eprint={1910.06711},
      archivePrefix={arXiv},
      primaryClass={eess.AS}
}
```

```bibtex
@misc{tagliasacchi2020seanet,
      title={SEANet: A Multi-modal Speech Enhancement Network}, 
      author={Marco Tagliasacchi and Yunpeng Li and Karolis Misiunas and Dominik Roblek},
      year={2020},
      eprint={2009.02095},
      archivePrefix={arXiv},
      primaryClass={eess.AS}
}
```

```bibtex
@misc{shen2023naturalspeech,
      title={NaturalSpeech 2: Latent Diffusion Models are Natural and Zero-Shot Speech and Singing Synthesizers}, 
      author={Kai Shen and Zeqian Ju and Xu Tan and Yanqing Liu and Yichong Leng and Lei He and Tao Qin and Sheng Zhao and Jiang Bian},
      year={2023},
      eprint={2304.09116},
      archivePrefix={arXiv},
      primaryClass={eess.AS}
}
```
chungso 0.1.1
S3 staging data (Parquet, JSON) offboarding tool
License: MIT
Keywords: parquet,s3,GDPR




## File Locations

Local Filesystem
S3

## Currently Supported File Types

- Parquet
    - filters out non-native parquet tables: iceberg, Hudi, delta lake
    - compression types:
        - SNAPPY
        - GZIP
        - LZO
        - BROTLI
        - LZ4
        - ZSTD

## Planned to SUpport File Types:

- ORC
- JSON
    - pyarrow doesnt have a JSON writer. so i'll write a simple wrapper
- CSV
    - must have a header
    - null values have to be handled well
django-k8s-health-check 1.2.0
Django Health Check
License: MIT
Requires Python: >=3.3

Django Health Check
=

If you use or like the project, click `Star` and `Watch` to generate metrics and i evaluate project continuity.

# Install:
    pip install django-k8s-health-check

# Usage Health only:
1. In your urls:
    ```
    from django_k8s_health_check.views import HealthView
    ...

    urlpatterns = [
        path('', views.HealthView.as_view()),
    ]
    ```

# Usage in kubernetes:

If use health check in kubernetes, you need to add kubernetes ip/host to django allowed_hosts,
but is a bad practice, especially if there are multiple ip/hosts...
For this, i created a middleware to pass dynamic ip/hosts, using multiples validators

1. Request Way

    1. Add the middleware to django middleware`s:
        ```
        MIDDLEWARE = [
            'django_k8s_health_check.middleware.HealthCheckMiddleware',
            ...
        ]
        ```

    1. Try this request:
        ```
        import requests
        requests.get('your-url', headers={'X-Health': 'health-check'})
        ```

    1. Put this in your yml
        ```
        livenessProbe:
            httpGet:
            path: /your-path
            httpHeaders:
            - name: X-Health
                value: health-check
            timeoutSeconds: 5
        ```
    1. Check de configuration section, and change for security reasons...

1. Command Way (test database and cache only, this not guarantee application is running):

    1. Add this app to your installed apps:
        ```
        INSTALLED_APPS = [
            'django_k8s_health_check',
        ]
        ```
    
    1. Try to run this command:
        ```
        python manage.py health_check
        ```
    
    1. Put this in your yml
        ```
        livenessProbe:
            exec:
                command: ["python", "manage.py", "health_check"]
            timeoutSeconds: 5
        ```

# Configuration:

```
HEALTH_CHECK = {
    # View
    'SERVICE_NAME': None,  # Used only in API
    'CHECK_DATABASE': True,
    'CHECK_CACHE': True,

    # Middleware (All bellow is used only in API)
    'HEADER_FIELD': 'X-Health',
    'HEADER_VALUE': 'health-check',
    'ALLOWED_PATHS': None,  # all others urls, use original ALLOWED_HOSTS. Ex: ['api/v1/health', '/health'], None allow all
    'ALLOWED_HOSTS': None,  # check request host is in a list, Ex: ['127.0.0.1', 'www.domain.com'], None allow all
}
```
kally 0.1.2
This is a clustering algorithm created based on the philosophy of competition for alliances, against the backdrop of the events of struggle for allies between warring countries. Especially the Russian-Ukrainian war.
License: MIT

Kally Project
===============
This is an alternative algorithm test project for clustering besides kmean and others. This project is funded by the Muhammadiyah University of Ponorogo, Indonesia. This algorithm is based on the philosophy of competence looking for allies.
Complete research results on this algorithm can be seen at https://github.com/elangbijak4/k-ally.1.0

Installing
============

.. code-block:: bash

    pip install kally

Usage
=====

.. code-block:: bash

    >>> import kally
    >>> result=kally(data,columns,k=3,min_index_data=0,iteration=10,treshold=0.05)