semvec/pypi-packages huggingface dataset:
snarkify-cli 0.1.7
The command line utility to interact with the Snarkify platform.
Requires Python: <4.0,>=3.8

# Snarkify CLI

The Snarkify CLI is a command-line tool designed to simplify the deployment and management of services on the Snarkify platform. It provides users with efficient commands to manage provers, shells, and other Snarkify services directly from the terminal.

## Installation

To install the Snarkify CLI, use pip:

```
pip install snarkify-cli
```

## Usage

For example usages, consult the [Snarkify documentation](https://docs.snarkify.io/gpu-prover-network/snakrify-cli) for details.
ownotp 0.1.2
Generate a time-based OTP using SHA-256 hashing algorithm
Requires Python: >=3.6

# OTP Generator
Generate a time-based OTP using SHA-256 hashing algorithm. 

### Installation
You can install the package using pip:
```shell
pip install ownotp
```

### Usage
Create 6 digits otp. OTP will change 2 minutes once based on `your_own_secrent`.
```python
from ownotp.otp import generate_otp

otp = generate_otp('your_own_secret')
print(otp)
```
To change interval time, pass the value in seconds.
```python
from ownotp.otp import generate_otp
otp = generate_otp('your_own_secret', interval=120)
```

To generate different length OTP.

Note: Minium 4 and Maximum 8 length will support. If condition not satisfied default length will take to generate OTP.
```python
from ownotp.otp import generate_otp
otp = generate_otp('your_own_secret', length=7)
```
To get hashed OTP. Mixed of char and numbers
```python
from ownotp.otp import generate_otp
otp = generate_otp('your_own_secret', only_digits=False)
```
clickd 0.1.1
Click group wrapper for loading click commands from separate files.
Requires Python: <4.0,>=3.12

# ClickD
Adds a click-based decorator that allows you to specify the directory with all the files being the subcommands/groups; and allows nesting the decorator--in the subdirectories' init-files--to traverse a directory tree for a quicker and cleaner cli-code layout.

## Install
```
pip install clickd
```

## Usage

Decorate the top-level--and all directory-modules' \_\_init\_\_ under--with the `clickd` 
decorator.


```
# <package-root-folder>/<cli-interface-top-level-folder>

./clickd/tests/cli  # <- this is the real test/example directory in this repo.
│   a.py
│   b.py
│   __init__.py
│
├───c
│   │   d.py
│   │   __init__.py
│   │
│   └───__pycache__
│           e.cpython-312.pyc
│           __init__.cpython-312.pyc
│
├───e
│   │   f.py
│   │   __init__.py
│   │
│   ├───g
│   │       j.py
│   │       __init__.py
│   │
│   └───h
│           k.py
│           __init__.py
│
└───__pycache__
        a.cpython-312.pyc
        b.cpython-312.pyc
        __init__.cpython-311.pyc
        __init__.cpython-312.pyc
```

The `__init__.py` files will contain `@clickd(dirp=./clickd/tests/cli/<folder>)`; for e.g.,
`h/__init__.py` will have:
```
from clickd import clickd

@clickd(dpath="./clickd/tests/cli/e/h")
def h():
    pass
```

And all the init-files in `./clickd/tests/cli/e/h` (and `./clickd/tests/cli/e`, and `./clickd/tests/cli`, for that matter) will have this set-up; every `click.Group` that I want to automatically load
subcommands as individual files from. 

The subcommands will, for e.g., look like this (in this case `./clickd/tests/cli/e/h/k.py`):
```
import click

@click.command()
def k():
    print("k")
```

Click can be used interoperably; the only thing that won't work is the `@clickd` groups
don't allow the use of `.add_command()`; I can use `@click.group()` as long as it is in
a file found by the `@clickd(dirpath=<path-to-folder-containing-file-with-group>)` or 
it is chained by a regular instance of `click.Group` that eventually parents-back to 
the `@clickd()`, which is a `click.MultiCommand` subclass called `ClickD`.  

I can use `@click.command(cls=ClickD, dirp=<path>)` above my group, instead--as a note.
cut-pursuit-l2 0.1.2
A Python implementation of the Cut Pursuit algorithm for graph optimization
Requires Python: >=3.7

# Cut Pursuit with L2 Norm

A Python implementation of the Cut Pursuit algorithm using L2 norm for graph optimization problems. This package provides working tools for graph partitioning using max-flow/min-cut optimization. While inspired by the original C++ version , this implementation is not an exact replica but more focused on speed optimization.

Some parameters such as the cut-off threshold are discarded for simplicity. For the original C++ implementation of the Cut Pursuit algorithm, please refer to the [cut-pursuit repository](https://github.com/loicland/cut-pursuit).

Several max-flow libraries have been evaluated, including PyMaxflow, SciPy's sparse module, NetworkX, and iGraph. Among these, PyMaxflow demonstrated the fastest performance. Notably, NetworkX offers CUDA support via RAPIDS and cuGraph; however, as of now, max-flow integration is lacking, and Windows support is limited.

The Cut Pursuit algorithm provides robust point clustering that preserves cluster shapes and edges, as demonstrated below:
<div align="center">
  <img width="340" alt="Cut Pursuit Clustering Example" src="https://github.com/user-attachments/assets/3697909c-2bc4-441a-ac58-4d382bf969e6">
</div>

## Installation

You can install the package via pip:

```bash
pip install cut-pursuit-l2
```

Or install directly from GitHub:

```bash
pip install git+https://github.com/truebelief/CutPursuit.git
```

## Requirements

- Python >=3.7
- NumPy <2.0.0
- SciPy
- PyMaxflow

## Basic Usage

Here's a simple example of how to use the Cut Pursuit algorithm:

```python
import numpy as np
from cut_pursuit import perform_cut_pursuit

# Generate sample point cloud data
points = np.random.rand(1000, 3)

# Set parameters
K = 4  # number of nearest neighbors
lambda_ = 1.0  # regularization strength

# Run Cut Pursuit
components = perform_cut_pursuit(K, lambda_, points)
```


## Advanced Usage

For more control over the algorithm, you can use the `CutPursuit` class directly:

```python
from cut_pursuit import CutPursuit, CPParameter

# Create instance
cp = CutPursuit(n_vertices=1000)

# Set custom parameters
cp.set_parameters(
    flow_steps=4,
    max_ite_main=20,
    stopping_ratio=0.001,
    reg_strenth=1.0
)

# Run optimization
energy_values, computation_times = cp.run()
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
prognosic-hub 0.1.0
Prognosic, backed by Hack Club (501(c)(3) EIN: 81-2908499), offers instant dataset access in just 2 lines of code, making ML model training easy.
Requires Python: >=3.6

Access to Medical Imaging Dataset Made EASY with Prognosic API! Download Vast Medical Imaging Datasets in JUST 2 lines of code!

Visit our website for more up-to date information: https://www.prognosic.com/
prognosic-fetch 0.1.0
Prognosic, backed by Hack Club (501(c)(3) EIN: 81-2908499), offers instant dataset access in just 2 lines of code, making ML model training easy.
Requires Python: >=3.6

Access to Medical Imaging Dataset Made EASY with Prognosic API! Download Vast Medical Imaging Datasets in JUST 2 lines of code!

Visit our website for more up-to date information: https://www.prognosic.com/