semvec/pypi-packages huggingface dataset:
libkvikio-cu12 26.2.0
KvikIO - GPUDirect Storage (C++)

# KvikIO: High Performance File IO

## Summary

KvikIO (pronounced "kuh-VICK-eye-oh", see [here](https://ordnet.dk/ddo_en/dict?query=kvik) for pronunciation of kvik) is a Python and C++ library for high performance file IO. It provides C++ and Python
bindings to [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html),
which enables [GPUDirect Storage (GDS)](https://developer.nvidia.com/blog/gpudirect-storage/).
KvikIO also works efficiently when GDS isn't available and can read/write both host and device data seamlessly.


### Features

* Object oriented API of [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html) with C++/Python exception handling.
* A Python [Zarr](https://zarr.readthedocs.io/en/stable/) backend for reading and writing GPU data to file seamlessly.
* Concurrent reads and writes using an internal thread pool.
* Non-blocking API.
* Transparently handles reads and writes to/from memory on both host and device.


### Documentation
 * Python: <https://docs.rapids.ai/api/kvikio/nightly/>
 * C++: <https://docs.rapids.ai/api/libkvikio/nightly/>


### Examples

#### Python
```python
import cupy
import kvikio

def main(path):
    a = cupy.arange(100)
    f = kvikio.CuFile(path, "w")
    # Write whole array to file
    f.write(a)
    f.close()

    b = cupy.empty_like(a)
    f = kvikio.CuFile(path, "r")
    # Read whole array from file
    f.read(b)
    assert all(a == b)
    f.close()

    # Use contexmanager
    c = cupy.empty_like(a)
    with kvikio.CuFile(path, "r") as f:
        f.read(c)
    assert all(a == c)

    # Non-blocking read
    d = cupy.empty_like(a)
    with kvikio.CuFile(path, "r") as f:
        future1 = f.pread(d[:50])
        future2 = f.pread(d[50:], file_offset=d[:50].nbytes)
        # Note: must wait for futures before exiting block
        # at which point the file is closed.
        future1.get()  # Wait for first read
        future2.get()  # Wait for second read
    assert all(a == d)


if __name__ == "__main__":
    main("/tmp/kvikio-hello-world-file")
```

#### C++
```c++
#include <cstddef>
#include <future>
#include <cuda_runtime.h>
#include <kvikio/file_handle.hpp>

int main()
{
  // Create two arrays `a` and `b`
  constexpr std::size_t size = 100;
  void *a = nullptr;
  void *b = nullptr;
  cudaMalloc(&a, size);
  cudaMalloc(&b, size);

  // Write `a` to file
  kvikio::FileHandle fw("test-file", "w");
  std::size_t written = fw.write(a, size);
  fw.close();

  // Read file into `b`
  kvikio::FileHandle fr("test-file", "r");
  std::size_t read = fr.read(b, size);
  fr.close();

  // Read file into `b` in parallel using 16 threads
  kvikio::default_thread_pool::reset(16);
  {
    // FileHandles have RAII semantics
    kvikio::FileHandle f("test-file", "r");
    std::future<std::size_t> future = f.pread(b_dev, sizeof(a), 0);  // Non-blocking
    std::size_t read = future.get(); // Blocking
    // Notice, `f` closes automatically on destruction.
  }
}
```
libkvikio-cu13 26.2.0
KvikIO - GPUDirect Storage (C++)

# KvikIO: High Performance File IO

## Summary

KvikIO (pronounced "kuh-VICK-eye-oh", see [here](https://ordnet.dk/ddo_en/dict?query=kvik) for pronunciation of kvik) is a Python and C++ library for high performance file IO. It provides C++ and Python
bindings to [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html),
which enables [GPUDirect Storage (GDS)](https://developer.nvidia.com/blog/gpudirect-storage/).
KvikIO also works efficiently when GDS isn't available and can read/write both host and device data seamlessly.


### Features

* Object oriented API of [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html) with C++/Python exception handling.
* A Python [Zarr](https://zarr.readthedocs.io/en/stable/) backend for reading and writing GPU data to file seamlessly.
* Concurrent reads and writes using an internal thread pool.
* Non-blocking API.
* Transparently handles reads and writes to/from memory on both host and device.


### Documentation
 * Python: <https://docs.rapids.ai/api/kvikio/nightly/>
 * C++: <https://docs.rapids.ai/api/libkvikio/nightly/>


### Examples

#### Python
```python
import cupy
import kvikio

def main(path):
    a = cupy.arange(100)
    f = kvikio.CuFile(path, "w")
    # Write whole array to file
    f.write(a)
    f.close()

    b = cupy.empty_like(a)
    f = kvikio.CuFile(path, "r")
    # Read whole array from file
    f.read(b)
    assert all(a == b)
    f.close()

    # Use contexmanager
    c = cupy.empty_like(a)
    with kvikio.CuFile(path, "r") as f:
        f.read(c)
    assert all(a == c)

    # Non-blocking read
    d = cupy.empty_like(a)
    with kvikio.CuFile(path, "r") as f:
        future1 = f.pread(d[:50])
        future2 = f.pread(d[50:], file_offset=d[:50].nbytes)
        # Note: must wait for futures before exiting block
        # at which point the file is closed.
        future1.get()  # Wait for first read
        future2.get()  # Wait for second read
    assert all(a == d)


if __name__ == "__main__":
    main("/tmp/kvikio-hello-world-file")
```

#### C++
```c++
#include <cstddef>
#include <future>
#include <cuda_runtime.h>
#include <kvikio/file_handle.hpp>

int main()
{
  // Create two arrays `a` and `b`
  constexpr std::size_t size = 100;
  void *a = nullptr;
  void *b = nullptr;
  cudaMalloc(&a, size);
  cudaMalloc(&b, size);

  // Write `a` to file
  kvikio::FileHandle fw("test-file", "w");
  std::size_t written = fw.write(a, size);
  fw.close();

  // Read file into `b`
  kvikio::FileHandle fr("test-file", "r");
  std::size_t read = fr.read(b, size);
  fr.close();

  // Read file into `b` in parallel using 16 threads
  kvikio::default_thread_pool::reset(16);
  {
    // FileHandles have RAII semantics
    kvikio::FileHandle f("test-file", "r");
    std::future<std::size_t> future = f.pread(b_dev, sizeof(a), 0);  // Non-blocking
    std::size_t read = future.get(); // Blocking
    // Notice, `f` closes automatically on destruction.
  }
}
```
anime-sama-apis 0.6.0
Api for anime-sama.fr
Requires Python: >=3.10
Keywords: anime, anime-sama, downloader

# Anime-Sama API

> [!IMPORTANT]  
> This is not the original package. The original one is from Sky-NiniKo on [Github](https://github.com/Sky-NiniKo/anime-sama_api)

An API for `anime-sama.org`.

I have implemented all the features I care about. This project is now in maintenance mode.

## Installation

Requirements:

- Python 3.10 or higher

You can simply install it with (note that you can use tools like pipx to isolate the installation):

```bash
pip install anime-sama-apis
```

## For developers

### Requirements

- git
- [uv](https://docs.astral.sh/uv/#installation)

### Install locally

```bash
git clone https://github.com/Sky-NiniKo/anime-sama_downloader.git
cd anime-sama_downloader
uv sync
```

### Run

```bash
uv run anime-sama
```

### Update

In the `anime_sama` folder:

```bash
git pull
```

### Contribution

I am open to contribution. Please only open a PR for ONE change. AKA, don't do "Various improvements" and explain your motivation behind your improvement ("Various typos fix"/"Cleanup" is fine).
x3d 4.0.65.0
Python package support for Extensible 3D (X3D) Graphics International Standard (IS)
Requires Python: >=3.1
Keywords: X3D, 3D, graphics, Web3D

## Python package *x3d*

This project creates the [Python X3D Package](https://www.web3d.org/x3d/stylesheets/python/python.html) which is available for import via [PyPI](https://pypi.org/project/x3d).

[Web3D Consortium](https://www.web3D.org) maintains this package under a BSD-style [open-source license](https://www.web3d.org/x3d/content/license.html).

### Package installation (choose one)

* *pip install x3d*
* *python -m pip install x3d*

### Package upgrade (choose one)
* *pip install x3d --upgrade*
* *python -m pip install x3d --upgrade*

### Developer Notes

* Package [x3d.py](http://www.web3d.org/x3d/stylesheets/python/x3d.py) provides full support for the [Extensible 3D (X3D) Graphics](https://www.web3D.org/x3d/what-x3d) International Standard.

* This package is also known as [X3DPSAIL, X3D Python Scene Access Interface Library](https://www.web3d.org/x3d/stylesheets/python/python.html).

* Code is autogenerated from [X3D Unified Object Model (X3DUOM)](http://www.web3d.org/specifications/X3DUOM.html) matching next-generation [X3D4](https://www.web3D.org/x3d4).


### Contact

* Designers and package maintainers: [Don Brutzman](mailto:don.brutzman@__gmail.com(Don%20Brutzman)?subject=x3d.py%20package%20inquiry) and [Loren Peitso NPS](mailto:lepeitso@__nps.edu(Loren%20Peitso)?subject=x3d.py%20package%20inquiry)

* Mail list: [x3d-public@web3D.org](mailto:x3d-public@__web3D.org?subject=x3d.py%20package%20inquiry) ([subscribe](http://www.web3d.org/mailman/listinfo/x3d-public_web3d.org))

* Contributors are gratefully acknowledged: Masaki Aono, John Carlson, Hans Moritz Guenther, Myeong Won Lee, Rick Lentz, and Vince Marchetti.