semvec/pypi-packages huggingface dataset:
cupy-chol 0.1.5
cupychol: Solve linear systems using Cholesky decomposition with CuPy arrays on GPU.
Requires Python: >=3.10

# CupyChol

CupyChol is a Python package for solving linear systems using Cholesky decomposition with CuPy arrays. It leverages CUDA and cuSOLVER to provide efficient solutions for large, sparse matrices on the GPU.

## Features

- Solve linear systems of the form `Ax = b` using Cholesky decomposition.
- Works with CuPy arrays, keeping data on the GPU for maximum efficiency.
- Utilizes CUDA and cuSOLVER for high performance.

## Installation

You can install CupyChol from PyPI:

```bash
pip install CupyChol
cyberdrop-dl 5.3.31
Bulk downloader for multiple file hosts
Requires Python: <4.0,>=3.11

# `cyberdrop-dl`

**Bulk downloader for multiple file hosts**

[![PyPI version](https://badge.fury.io/py/cyberdrop-dl.svg)](https://badge.fury.io/py/cyberdrop-dl)
[![Downloads](https://static.pepy.tech/badge/cyberdrop-dl)](https://pepy.tech/project/cyberdrop-dl)
[![Downloads](https://static.pepy.tech/badge/cyberdrop-dl/month)](https://pepy.tech/project/cyberdrop-dl)
[![Downloads](https://static.pepy.tech/badge/cyberdrop-dl/week)](https://pepy.tech/project/cyberdrop-dl)

[![Discord Banner 3](https://discordapp.com/api/guilds/1070206871564197908/widget.png?style=banner3)](https://discord.com/invite/kbZCxz22Qp)

Brand new and improved! Cyberdrop-DL now has an updated paint job, fantastic new look. It's now easier to use than ever before!

![Screenshot 2023-12-03 190747](https://github.com/Jules-WinnfieldX/CyberDropDownloader/assets/61347133/aa6b7e21-a039-42e9-9308-ca62750a49cf)

## Supported Sites

bunkr, bunkrr, celebforum, coomer, cyberdrop, cyberfile, e-hentai, erome, fapello, f95zone, gofile, hotpic, ibb.co, imageban, imgbox, imgur, img.kiwi, jpg.church, jpg.homes, jpg.fish, jpg.fishing, jpg.pet, jpeg.pet, jpg1.su, jpg2.su, jpg3.su, jpg4.su, host.church, kemono, leakedmodels, mediafire, nudostar.com, nudostar.tv, omegascans, pimpandhost, pixeldrain, postimg, realbooru, reddit, redd.it, redgifs, rule34.xxx, rule34.xyz, rule34vault, saint, scrolller, simpcity, socialmediagirls, toonily, xbunker, xbunkr

## Installation and More Information

Read the [Wiki!](https://jules-winnfieldx.gitbook.io/cyberdrop-dl/)

You can find how to install the program and how to use it there. You can also find a list of supported hosts, and frequently asked questions.
get-rankings 1.0
DBLP ranking using CORE Rank and SJR
Requires Python: >=3.6

# DBLP ranking using CORE Rank and SJR

## Install

``` bash
pip install get_rankings
```

## Run

```
get_rankings DBLP_URL
```

Gives and overview of a dblp account. The first run will be slow as some data will be cached.

For example

```
get_rankings https://dblp.org/pid/37/2282.html
```

## Usage
```
usage: get_rankings [-h] [--start START] [--end END] [-o output.csv] [-d] [--debug] [-v] url

Get ranking from DBLP and show a small summary

positional arguments:
  url            DBLP url

options:
  -h, --help     show this help message and exit
  --start START  starting year
  --end END      ending year
  -o output.csv  output csv file
  -d             display conference and journal list
  --debug        Print lots of debugging statements
  -v, --verbose  Be verbose
```

## Thanks

Thanks for Laurent Reveillere ([dblp_ranker](https://github.com/reveillere/dblp_ranker) and Xavier Blanc [dblp_ranker](https://github.com/xblanc33/dblp_ranker) for their initial version in nodejs.
drf-comments 1.2.1
A library for adding comments to models using Django REST Framework.
Requires Python: >=3.8

# DRF-Commnts

A library for adding comments to models using Django REST Framework.

## Installation
```bash
pip install drf-comments
```

## Usage

```python
from drf_comments.comments import BaseComment, CommentViewSet, comment_serializer, create_comment_serializer

# Define your models
class Post(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    title = models.CharField(max_length=255)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.title

class PostComment(BaseComment):
    post = models.ForeignKey(Post, on_delete=models.CASCADE)

    class Meta(BaseComment.Meta):
        db_table = 'posts_postcomment'
        verbose_name = 'Post Comment'
        verbose_name_plural = 'Post Comments'

# Define your serializers
class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ['id', 'user', 'title', 'content', 'created_at', 'updated_at']

PostCommentSerializer = comment_serializer(PostComment)
PostCommentCreateSerializer = create_comment_serializer(PostComment)

# Define your viewsets
class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer
    permission_classes = [IsAuthenticated]
    authentication_classes = [TokenAuthentication]

class PostCommentViewSet(CommentViewSet):
    queryset = PostComment.objects.all()
    serializer_class = PostCommentSerializer
    create_serializer_class = PostCommentCreateSerializer
    permission_classes = [IsAuthenticated]
    authentication_classes = [TokenAuthentication]
kv-api 0.1.24
Interface for any Key-Value DB. Completely exception-free, and backed by `haskellian` for powerful composability
Requires Python: >=3.10

# Key-Value API

> ABC for a an async key-value store

```bash
pip install kv-api
```

## Spec

```python
class KV(Generic[T]):
  
  async def insert(self, key: str, value: T) -> Either[DBError, None]:
    ...

  async def read(self, key: str) -> Either[ReadError, T]:
    ...

  async def delete(self, key: str) -> Either[DBError | InexistentItem, None]:
    ...

  async def items(self, batch_size: int | None = None) -> AsyncIter[Either[DBError | InvalidData, tuple[str, T]]]:
    ...

  async def has(self, key: str) -> Either[DBError, bool]:
    ...
  
  async def keys(self) -> Either[DBError, Sequence[str]]:
    ...

  async def values(self, batch_size: int | None = None) -> AsyncIter[Either[DBError|InvalidData, T]]:
    ...

  async def copy(self, key: str, to: KV[T], to_key: str) -> Either[DBError|InexistentItem, None]:
    ...

  async def move(self, key: str, to: KV[T], to_key: str) -> Either[DBError|InexistentItem, None]:
    ...
```

## Usage

- All functions return `Either` instead of throwing
- For chaining multiple operations, it is recommended to use a kind of do notation for `Either`, using exceptions
  - `Either.unsafe()` unwraps the right value or raises `IsLeft`

```python
from kv.api import KV, DBError
from haskellian import Either, IsLeft

async def multi_copy(key_from: str, keys_to: str, data: KV[bytes]) -> Either[DBError, None]:
  try:
    value = (await data.read(key_from)).unsafe()
    for key in keys_to:
      (await data.insert(key, value)).unsafe()
    return Right(None)
  except IsLeft as e:
    return Left(e.value)
```

## Extensions

### `AppendableKV[T]`

> A `KV[Sequence[T]]` that supports appending

```python
class AppendableKV(KV[Sequence[T]], Generic[T]):
  async def append(self, id: str, values: Sequence[T], *, create: bool) -> Either[DBError|InexistentItem, None]:
    ...
```

### `LocatableKV[T]`

> A `KV[T]` whose items can be accessed via some URL

```python
class LocatableKV(KV[T], Generic[T]):
  def url(self, id: str) -> str:
    ...
```

## Implementations

- [`kv-fs`](https://pypi.org/project/kv-fs/): on the local filesystem
- [`kv-sqlite-sync`](https://pypi.org/project/kv-sqlite-sync/): on SQLite with python's `sqlite3` synchronous interface
- [`kv-rest`](https://pypi.org/project/kv-rest/): client, over HTTP, to a server-side KV
- [`kv-azure-blob`](https://pypi.org/project/kv-azure-blob/): on Azure Blob Storage
PySubtitle 0.1.2
A python library to generate subtitles from a video

# PySubtitle

PySubtitle is a Python library designed to automate the process of generating subtitles for video files. It extracts audio from video files, converts the audio to text using Google's speech recognition services, and generates VTT (Web Video Text Tracks) files for subtitles. This library is particularly useful for creating subtitles for videos in various languages, making content more accessible to a wider audience.

## Features

- **Audio Extraction**: Extracts audio from video files using `ffmpeg`.
- **Speech Recognition**: Converts audio to text using Google Cloud Speech-to-Text API.
- **Subtitle Generation**: Creates VTT files from the transcribed text, with accurate timing and synchronization.
- **Cross-Platform**: Works on Windows, macOS, and Linux.

## Prerequisites

Before installing and using this library, you need to ensure the following prerequisites are met:

1. **FFmpeg**: This library requires `ffmpeg` to handle video and audio processing. Here's how you can install `ffmpeg`:

   ### On Ubuntu:
   ```bash
   sudo apt update
   sudo apt install ffmpeg
   ```

   ### On macOS:
   ```bash
   brew install ffmpeg
   ```

   ### On Windows:
   Download the binaries from [FFmpeg Official Site](https://ffmpeg.org/download.html) and follow the installation instructions.

2. **Google Cloud Service Key**: This library uses Google Cloud Speech-to-Text API for speech recognition. You need to set up a Google Cloud project and download a service key. Follow these steps:
   - Go to the [Google Cloud Console](https://console.cloud.google.com/).
   - Create a new project or select an existing one.
   - Enable the Speech-to-Text API for your project.
   - Go to "Credentials" and create a new service account key.
   - Download the JSON key file and set the environment variable `GOOGLE_APPLICATION_CREDENTIALS` to the path of the JSON file.

## Installation

To install this library, use pip:

```bash
pip install PySubtitle
```

## Usage

Here is a simple example of how to use this library:

```python
from PySubtitle.audio_extraction import extract_audio
from PySubtitle.speech_recognition import audio_to_text
from PySubtitle.vtt_generation import generate_vtt
from PySubtitle.languages import Languages

# Path to your video file
video_path = 'path/to/your/video.mp4'

# Extract audio
audio_path = extract_audio(video_path)

# Convert audio to text
transcripts, durations = audio_to_text(audio_path, Languages.ENGLISH.value)

# Generate VTT file
vtt_file = 'output.vtt'
generate_vtt(transcripts, durations, vtt_file)
```

## Contributing

Contributions are always welcome! Please fork the repository and submit a pull request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
base36py 0.2.0
A lightweight Python library for encoding and decoding numbers between base10 and base36.
Requires Python: >=3.6

# base36py

`base36py` is a lightweight Python library for encoding and decoding numbers between base10 and base36. It provides functions to convert both integer and floating-point numbers to base36 strings and vice versa, supporting precise fractional conversions.

## Features

- Convert integers to base36 strings.
- Convert floating-point numbers to base36 strings with adjustable precision.
- Decode base36 strings back to integers or floating-point numbers.
- Easy to use and integrate into existing projects.

## Installation

You can install `base36py` via pip:

```sh
pip install base36py
```

## Usage

```python
from base36py import encode, decode

encoded = encode(1234.5678, precision=8)
print("Encoded:", encoded)
decoded = decode(encoded, precision=8)
print("Decoded:", decoded)
```
Scrapins 0.2.2
Une description personnelle pour des outils de Scraping
Requires Python: >=3.6

## Configuration OpenAI

Pour utiliser les fonctionnalités liées à l'API OpenAI, vous devez créer un fichier `openai.json` dans le répertoire racine de votre projet avec le contenu suivant :

```json
{
    "api_key": "votre_cle_api_openai"
}
```
multispectral-processor 0.1.0
A package to process multispectral images.
Requires Python: >=3.6

# multispectral_processor

A package to process multispectral images.

## Installation

 ```bash
    pip install multispectral_processor
```

## Usage

```python
from multispectral_processor import process_multispectral_data

base_dir = '/path/to/Spectral_Images'
channels = ['Red_Edge_Channel', 'Red_Channel', 'Green_Channel', 'Near_Infrared_Channel']
train_images = '/path/to/train_images'
test_images = '/path/to/test_images'

process_multispectral_data(base_dir, channels, train_images, test_images)
'''