semvec/pypi-packages huggingface dataset:
accelbyte-py-sdk-service-ams 0.25.0
AccelByte Python SDK - Fleet Commander
Requires Python: >=3.9

[//]: # (Code generated. DO NOT EDIT!)

# AccelByte Modular Python SDK - Service Module

This is a service module for the [AccelByte Modular Python SDK](https://github.com/AccelByte/accelbyte-python-modular-sdk) package.

```text
Fleet Commander
* Version: 1.43.0
```

## Setup

This SDK requires Python 3.9 to be installed.

### Install with Pip

Install the core package from PyPI

```sh
pip install accelbyte-py-sdk-core
```

install *this* service

```sh
pip install accelbyte-py-sdk-service-ams
```

and then install any service or feature you want

```sh
pip install accelbyte-py-sdk-service-{ SERVICE }
```

```sh
pip install accelbyte-py-sdk-feat-{ FEATURE }
```

or install everything

```sh
pip install accelbyte-py-sdk-all
```

## Usage

See [README.md](https://github.com/AccelByte/accelbyte-python-modular-sdk/blob/main/README.md)
typeitnow 0.1.3
A terminal-based typing game inspired by bop it.
Requires Python: >=3.13


# typeitnow

typeitnow is a terminal-based game inspired by Bop It.
As the player, you're tasked with typing in the words presented
to you before the timer runs out.
It has multiple difficulties, and can be played for fun
or to practice touch-typing.
The initial idea was to have the player press a single key,
which is more similar to Bop It.
That idea was more fun to implement, but less fun to play(to me).
Maybe I'll add it back as an option. Hope you have fun! :)

## OS

typeitnow works on Linux. It should work on Mac and Windows as well,
but has not been tested.

## Installation

1. FluidSynth (2.0.0 or later) is required. You can find instructions on how
to install it here: [FluidSynth Download](https://github.com/FluidSynth/fluidsynth/wiki/Download)
2. Install typeitnow with pip.

    ```sh
    pip install typeitnow
    ```

3. Add the .sf2 file so the audio sounds right.
    - Download `undertale.sf2` from the latest Github Release page in this
repository - [release page](https://github.com/benbunsford/typeitnow/releases/tag/v0.1.0-alpha)
    - Put it in `typeitnow/src/music`
4. Run typeitnow in your terminal.

    ```sh
    typeitnow
    ```

## TODO

- add high score tracking
- re-implement single-key mode
separate 1.1.0
Storm Event Partitioning And Rainfall Analytics for Tipping-bucket rain gage Evaluation (SEPARATE)
Requires Python: <3.13,>=3.11

# SEPARATE

**Storm Event Partitioning And Rainfall Analytics for Tipping-bucket rain gauge data Evaluation (SEPARATE)**  
*Core Python functions for partitioning storm events from tipping-bucket rain gauge data.*

---

## What This Package Includes

This PyPI version includes only the **backend Python functions** used to partition storm events and calculate rainfall metrics.  
It is intended for developers who want to contribute to backend functionality or use SEPARATE in scripted workflows.  
**It does not include the GUI or prepackaged datasets.**

However, you can manually install PySimpleGUI after installing this package using a wheel file and download the associated images from the GitHub repository if you would like to use the GUI from this installation.

---

## Installation

```bash
pip install separate
```

> **Note:** PySimpleGUI is not included in this version.**  
> This version is intended for users who want to use SEPARATE functions in scripts or notebooks, rather than GUI-based applications.

---

## Example Usage

```python
# In Python, you can import core functions like this:
from separate.functions import SEPARATE_FUNCTIONS as sf
```

An example script for using these functions to execute the SEPARATE workflow can be found in  
[`SEPARATE_standalone_script.py`](https://github.com/WatershedsWildfireResearchCollaborative/SEPARATE/blob/main/SEPARATE_standalone_script.py) on our GitHub repository.

---

## Documentation

For the full GUI version and a detailed user manual (including screenshots and example workflows), please see the GitHub repository:

[SEPARATE on GitHub](https://github.com/WatershedsWildfireResearchCollaborative/SEPARATE)

---

## Authors

- Brendan Murphy (Simon Fraser University)
- Scott David (Utah State University)

---

## License

Licensed under the MIT License. See `LICENSE` for details.

---

## How to Use This

This version is ideal if you:
- Want to import SEPARATE's logic into your own analysis pipelines
- Need to script batch processing or run headless workflows
- Are not using the GUI
notears-pytorch 0.3.0
A PyTorch implementation of the NOTEARS Linear algorithm for causal discovery.
Requires Python: >=3.6
Keywords: causal-discovery, structure-learning, dag, pytorch, notears, notears-linear, linear causal discovery, causal discovery gpu




A PyTorch implementation of the NOTEARS algorithm (Non-parametric Optimization for Structure Learning) for causal discovery.

This package provides a continuous optimization approach to learning DAGs (Directed Acyclic Graphs) from data, harnessing the power of GPUs to accelerate the learning process.

Note: The original NOTEARS Linear implementation is CPU only.

📦 Installation

You can install this package directly from PyPi:

```

pip install notears-pytorch


```

🚀 Usage

Below is a basic example of how to use the linear NOTEARS algorithm.

```
from notears_pytorch import notears_linear


# 2. Run optimization
# Returns a binary adjacency matrix where B[i, j] = 1 implies i -> j
adj_matrix = notears_linear(X, lambda1=0.1, w_threshold=0.3)

print("Estimated Adjacency Matrix:")
print(adj_matrix)


```

📚 API Description 

### `notears_linear`

```python
notears_linear(X, lambda1=0.1, rho_init=1.0, alpha_init=0.0, 
               outer_iter=50, inner_iter=100, init_lr=1e-2, 
               h_tol=1e-8, w_threshold=0.3, use_gpu=False)
```

**Arguments:**
- `X` (`np.ndarray`): Input data matrix of shape (n_samples, n_features).
- `lambda1` (`float`): L1 regularization strength for sparsity.
- `rho_init` (`float`): Initial penalty parameter for the augmented Lagrangian.
- `alpha_init` (`float`): Initial value for the Lagrange multiplier.
- `outer_iter` (`int`): Number of outer optimization iterations.
- `inner_iter` (`int`): Number of inner Adam optimizer iterations per sub-problem.
- `init_lr` (`float`): Initial learning rate for Adam optimizer.
- `h_tol` (`float`): Tolerance for the acyclicity constraint.
- `w_threshold` (`float`): Threshold for pruning weak edges in the adjacency matrix.
- `use_gpu` (`bool`): If `True`, computation is performed on GPU (if available).

**Returns:**
- `np.ndarray`: Estimated binary adjacency matrix of shape (n_features, n_features), where entry `[i, j] = 1` indicates a directed edge from node `i` to node `j`.

**Description:**
This function runs the linear NOTEARS algorithm to estimate the structure of a directed acyclic graph (DAG) from observational data. It uses continuous optimization and supports GPU acceleration for faster computation.


📄 Citation

If you use this implementation in your research, please cite this GitHub repository and the original paper:

Zheng, X., Aragam, B., Ravikumar, P. K., & Xing, E. P. (2018). DAGs with NO TEARS: Continuous Optimization for Structure Learning. Advances in Neural Information Processing Systems.
ivp-rs 0.1.2
A Rust library for solving initial value problems (IVPs) for ordinary differential equations (ODEs).
Requires Python: >=3.9
Keywords: differential, equations, solve_ivp, ode, ivp

<p align="center">
  <img src="./assets/logo.svg" width="1000" alt="ivp">
</p>

<p align="center">
    <a href="https://crates.io/crates/ivp">
        <img src="https://img.shields.io/crates/v/ivp.svg?style=flat-square" alt="crates.io">
    </a>
    <a href="https://docs.rs/ivp">
        <img src="https://docs.rs/ivp/badge.svg" alt="docs.rs">
    </a>
    <a href="https://github.com/Ryan-D-Gast/ivp/blob/main/LICENSE">
        <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg">
    </a>
</p>

<p align="center">
    <strong>
        <a href="https://docs.rs/ivp/latest/ivp/">Documentation</a> |
        <a href="./examples/">Examples</a> |
        <a href="https://github.com/Ryan-D-Gast/ivp">GitHub</a> |
        <a href="https://crates.io/crates/ivp">Crates.io</a>
    </strong>
</p>

-----

<p align="center">
<b>A library of numerical methods for solving initial value problems (IVPs)</b><br>
<i>for the Rust programming language.</i>
</p>

-----

This library provides a pure rust implementation of SciPy's `solve_ivp` function with slight modifications to the API to better fit Rust's design patterns.

Currently implemented solvers:
-   **DOP853**: An 8th order Dormand-Prince method with step-size control and dense output.
-   **DOPRI5**: A 5th order Dormand-Prince method with step-size control and dense output.
-   **RK4**: The classic 4th order Runge-Kutta method with fixed step-size and cubic Hermite interpolation for dense output.
-   **RK23**: A 3rd order Runge-Kutta method with 2nd order error estimate for step-size control.
-   **Radau**: A 5th order implicit Runge-Kutta method of Radau IIA type with step-size control and dense output.
-   **BDF**: A variable-order (1 to 5) Backward Differentiation Formula method for stiff ODEs with adaptive step-size control and dense output.

> Note: This crate uses dynamically sized arrays (`Vec`) internally to provide flexibility and to simplify Python bindings. For workloads that require maximal performance with statically sized arrays (compile-time sizes), consider the `differential-equations` project, which provides additional solvers and features (SDEs, DDEs, DAEs). This crate targets users seeking a Rust implementation of SciPy's `solve_ivp` with a familiar API.
netbox-sitemap 0.3.0
NetBox plugin for displaying sites on a map.
Requires Python: >=3.10.0

# NetBox Sitemap Plugin

NetBox plugin for displaying sites on a map.


* Free software: MIT
* Documentation: https://Larster05.github.io/netbox-sitemap/


## Features

NetBox plugin for displaying sites on a map.

## Compatibility

| NetBox Version | Plugin Version |
|----------------|----------------|
|     4.0        |      0.3.0     |

## Installing

For adding to a NetBox Docker setup see
[the general instructions for using netbox-docker with plugins](https://github.com/netbox-community/netbox-docker/wiki/Using-Netbox-Plugins).

While this is still in development and not yet on pypi you can install with pip:

```bash
pip install netbox-sitemap
```
or by adding to your `local_requirements.txt` or `plugin_requirements.txt` (netbox-docker):


Enable the plugin in `/opt/netbox/netbox/netbox/configuration.py`,
 or if you use netbox-docker, your `/configuration/plugins.py` file :

```python
PLUGINS = [
    'netbox_sitemap'
]

PLUGINS_CONFIG = {
    "netbox_sitemap": {},
}
```

## Credits

Based on the NetBox plugin tutorial:

- [demo repository](https://github.com/netbox-community/netbox-plugin-demo)
- [tutorial](https://github.com/netbox-community/netbox-plugin-tutorial)

This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [`netbox-community/cookiecutter-netbox-plugin`](https://github.com/netbox-community/cookiecutter-netbox-plugin) project template.
EGAIN 0.0.1
Enhanced Generative Adversarial Networks for Imputing Missing Values
Requires Python: >=3.11

# EGAIN
Abolfazl Saghafi, Soodeh Moallemian, Miray Budak, and Rutvik Deshpande, EGAIN: Enhanced Generative Adversarial Networks for Imputing Missing Values, Under Review.

# Requirements
The codes require `python >= 3.11`. Main required libraries and their versions are:
```console
numpy >= 1.26.4
pandas >= 2.2.2
tensorflow >= 2.18.0
scikit-learn >= 1.6.1
matplotlib >= 3.10.0
tqdm >= 4.67.1
```

# Installation
First install the above requirements with their versions using `pip`, then instal EGAIN using `pip`, and load required libraries:
```console
!pip install EGAIN

## Import requirements
##-------------------
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from tqdm import tqdm
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Input, Flatten, MaxPooling1D, Conv1D
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import root_mean_squared_error
from EGAIN import EGAIN
from EGAIN import plot_losses, rounding, rmse_loss
```
Alternatively, you can install EGAIN directly from this github page. This option works great if you are using google collaboratory: 
```python
## Clone EGAIN 
!git clone https://github.com/asaghafi/EGAIN.git

## Install requirements
%cd /content/EGAIN
!pip install -r requirements.txt

## Import utility functions
import sys
sys.path.append('/content/EGAIN')
from utils import *
from EGAIN import EGAIN
```


# Best hyperparameters
To find the best `alpha`, best iterations, and best batch size follow instructions at the github page:
https://github.com/asaghafi/EGAIN
mute-mic 0.1.0
Small command to (un)mute the mic in Windows
Requires Python: >=3.10

# mute-mic

Windows does not have a command to globally (un)mute your microphone which can be mapped
from a key. `mute-mic` solves that problem.

## Install

[UV](https://docs.astral.sh/uv/getting-started/installation/) makes it easy to install command line programs made in Python.

With UV, you can install `mute-mic`:

`uv tool install mute-mic`

## Usage

From the command line, you can call `mute-mic` to mute or unmute your microphone.
You can map a key to this program with ie Powertoys (get the path to the command via `where mute-mic` and
choose Hidden as visibility)