semvec/pypi-packages huggingface dataset:
pylcs-rs 0.1.2
Fast LCS algorithms implemented in Rust
Requires Python: >=3.8

# pylcs-rs

This is a Rust port of the [pylcs](https://github.com/Meteorix/pylcs) project.

## benchmark

on M4 MacOS

```
$ docker build -t lcsbench -f benchmark.dockerfile.aarch64 .
$ docker run -it --rm lcsbench
```

```
Input Sizes                    | pylcs_rs            | pylcs
------------------------------------------------------------------------
(3, 7)                         | 0.000001 ±0.000001 | 0.000001 ±0.000002
(5, 3)                         | 0.000001 ±0.000001 | 0.000001 ±0.000000
(1000, 1100)                   | 0.003899 ±0.000217 | 0.002706 ±0.000069
(1500, 1500)                   | 0.008471 ±0.000209 | 0.005510 ±0.000138
(1100, 1100)                   | 0.003577 ±0.000050 | 0.002596 ±0.000030
(520, 520)                     | 0.000800 ±0.000047 | 0.000569 ±0.000013
```

## development

Build and Test Rust Modules

```
cargo test
```

Install dev dependencies

```
uv sync
```

Build for editable package

```
uv run maturin develop --uv
```

Test Python Module

```
uv run pytest
```

build for release

```
uv run maturin build --release
```

The Artifact should be like: `./target/wheels/pylcs_rs-0.1.0-cp312-cp312-*.whl`
JavaLib 0.2
JavaLib is a Python library that provides several functions and classes to manipulate strings and count the number of elements, using Java language terms.
Requires Python: >=3.10

# JavaLib

JavaLib is a Python library that provides several functions and classes for manipulating strings and counting the number of elements, using Java language terms. 

## Features

- The `print()` function**: Replaces the built-in `print()` function to print output to the console.
  
- **Function `dowo()`**: Replaces the built-in `len()` function to count the number of elements in the object.

- **The `type()` function**: Replaces the built-in `type()` function to get the type of the object.

- **Separator class**: This class is used to separate strings based on a specific separator, similar to the `split()` function.

## Installation

You can install JavaLib by using pip:

```bash
pip install JavaLib
```
## Function and Class Explanation
1. `print(*args, **kwargs):`
- Replaces the `print()` function.
- Accepts the same arguments as `print()`.

2. `dowo(object):`
- Replaces the `len()` function.
- Accepts an object and returns the number of elements in the object.

3. `type(object):`
- Replaces the `type()` function.
- Accepts an object and returns the type of the object.

4. Separator Class:
- `__init__(text):` Constructor that accepts strings to split.
- `split(sep=None`, `maxsplit=-1):` Splits the string based on the given separator. If there is no separator, it will split based on spaces.

## License
This project is licensed under the Apache License 2.0. See LICENSE for more details.

## Contributions
If you would like to contribute to this project, please create a pull request or open an issue in the GitHub repository.

#### Note: Contributions are only for people who speak Javanese.
bin2coe 1.1.2
A tool to convert binary files to COE files
Requires Python: >=3.7
Keywords: bram, coe, xilinx

# bin2coe [![Build Status](https://github.com/anishathalye/bin2coe/workflows/CI/badge.svg)](https://github.com/anishathalye/bin2coe/actions?query=workflow%3ACI)

bin2coe is, as its name suggests, a tool to convert binary files to [COE] files
for initializing Xilinx FPGA block RAM.

Usage
-----

Basic usage looks like this:

```bash
bin2coe -i INPUT -w WIDTH -o OUTPUT
```

Additionally, you can specify depth manually (rather than having it be
inferred), specify a value to fill in empty words, and specify the radix. See
`bin2coe --help` for more information.

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

bin2coe can be installed from [PyPI]:

```bash
pip install bin2coe
```

After running this command, the `bin2coe` binary should be available on your
`$PATH`.

License
-------

Copyright (c) Anish Athalye. Released under the MIT License. See
[LICENSE.md][license] for details.

[COE]: https://docs.xilinx.com/r/en-US/ug896-vivado-ip/COE-File-Syntax
[PyPI]: https://pypi.org/project/bin2coe/
[license]: LICENSE.md
gpu-wait 0.4.9
A package to run commands when GPU resources are available
Requires Python: >=3.6

# GPU Wait

A Python package that monitors GPU resources and executes commands when the GPU becomes available.

## Installation

```bash
pip install gpu-wait
```

## Usage

### Command Line Interface

```bash
# Run a command when any GPU is available
gpu-wait "python train.py"

# Wait for specific GPU
gpu-wait -d 0 "python train.py"

# Customize memory threshold and polling interval
gpu-wait -t 0.8 -i 5 "python train.py"

# Enable verbose logging
gpu-wait -v "python train.py"
```

### Python API

```python
from gpu_wait import GPUMonitor, CommandRunner

# Create monitor with custom threshold
monitor = GPUMonitor(memory_threshold=0.8)

# Create command runner
runner = CommandRunner(monitor)

# Run command when GPU is available
runner.run_when_available("python train.py")
```

## Features

- Monitor single or multiple GPUs
- Customizable memory threshold and polling interval
- Command line interface
- Python API
- Logging support

## Requirements

- Python 3.6+
- NVIDIA GPU
- nvidia-ml-py
- psutil
- click

## License

MIT License