semvec/pypi-packages huggingface dataset:
commitizen-ros 0.1.0
A ROS Version Provider for Commitizen
Requires Python: >=3.4
Keywords: ROS, Commitizen, Version Provider

# Commitizen ROS

A python package implementing a Commitizen Version Provider for ROS Package
Manifests

## Quick Start

Install with `pip`...

```bash
python3 -m pip install commitizen-ros
```

...and add the provider to your Commitizen configuration:
```toml
[tool.commitizen]
version_provider = [.., "commitizen_ros", ...]
```

## Description

The Commitizen ROS package adds ROS 1 and 2 `project.xml` package manifests
defined as per [REP127 (format 1)](https://ros.org/reps/rep-0127.html) and
[REP140 (format 2)](https://www.ros.org/reps/rep-0140.html) as sources and
targets for version data in
[Commitizen](https://commitizen-tools.github.io/commitizen/).


## Usage
No configuration is required (beyond adding the provider to your Commitizen
configuration) as the ROS `project.xml` name and location and contents are
specified by REPs 127 and 140.


## License
This package is licensed under the MIT License
WGM_api 0.1.19
A Python client library for managing WireGuard server users and sessions.
Requires Python: <4.0,>=3.10

# WGM - API Client for WireGuard Management

## Overview

`WGM` is a Python client library designed to interact with a WireGuard server API. This library enables actions such as creating, deleting, enabling, and disabling users, as well as managing sessions and retrieving user information.

## Features

- **Session Management**: Start a session with the server using provided credentials (IP, port, password).
- **User Management**: Retrieve a list of all users, and perform actions like create, delete, enable, and disable users.
- **Session Re-establishment**: Automatically re-establishes a session if authentication fails.
- **HTTP Method Support**: Supports `POST`, `DELETE`, `PUT` HTTP methods for data manipulation.
  
## Installation

To install dependencies, use [Poetry](https://python-poetry.org/). Just run the command:

```bash
poetry install
```
This will install all the dependencies specified in project.toml.

## Using WGM

```python
from WGM_api import WGM_api

# Session initialization #
session = WGM_api()

# Set up a session with the server #
session.start_session(ip_address="ip_address", port=port, password="your_password")

# Example of creating a new user #
session.create_user(name="user_name")

# Example of deleting a user #
session.delete_user(value="existing_user")

# When creating a user, we must specify the desired name, while when deleting a user, it can be done either by name or by ID. #
```

### Methods

- **start_session(ip_address, port, password)** — Initializes a session with the server.
- **get_all_users()** — Retrieves a list of all users.
- **create_user(name)** — Creates a new user.
- **delete_user(value)** — Deletes a user (by name or ID).
- **enable_user(value)** — Enables the user (by name or ID).
- **disable_user(value)** — Disables the user. (by name or ID).
- **download_config(value)** — Download config file the user. (by name or ID).

## PyPI

The `WGM` library is available on [PyPI](https://pypi.org/project/wgm_api/), making it easy to install and integrate into your projects.

Install it via `pip`:
```bash
pip install wgm_api
```
Or poetry:
```bash
poetry add wgm_api
```

<div align="center">

## Libraries in this project

[![Python](https://img.shields.io/badge/Python-3.8%20|%203.9%20|%203.10%20|%203.11%20|%203.12-orange?logo=python&color=blue)](https://www.python.org/downloads/) [![Requests](https://img.shields.io/badge/Requests-^2.32.3-brightgreen?logo=Requests&color=green)](https://requests.readthedocs.io/en/latest/)

<i>Version 1.0.0 | Release Date: November 21, 2024</i>
</div>
torch-adopt 0.1.0
ADOPT: Modified Adam Can Converge with Any β2 with the Optimal Rate
Requires Python: >=3.8

# ADOPT: Modified Adam Can Converge with Any $β_2$ with the Optimal Rate
Official Implementation of "[ADOPT: Modified Adam Can Converge with Any β<sub>2</sub> with the Optimal Rate](https://arxiv.org/abs/2411.02853)", which is presented at NeurIPS 2024.

## Update on Nov 22, 2024

Based on feedbacks from some practitioners, we have updated the implementation to improve the stability of our ADOPT algorithm.
In the original version, ADOPT sometimes gets unstable especially in the early stage of training.
This seems to be because the near-zero division by the second memont estimate occurs when some elements of the parameter gradient are near zero at initialization.
For example, when some parameters (e.g., the last layer of a neural net) are initialized with zero, which is often-used technique in deep learing, a near-zero gradient is observed at the first parameter update.
To avoid such near-zero divisions, we have decided to add a clipping operation in the momentum update.

![clipped_adopt](https://github.com/user-attachments/assets/244cb934-8c73-4f89-b9c4-7b94f292af5f)

Even when clipping is applied, the convergence guarantee in theory is maintained by properly scheduling the clipping value (see the updated arXiv paper).
In our implementation, the clipping value is controlled by the argument `clip_lambda`, which is a callable function that determines the schedule of the clipping value depending on the number of gradient steps.
By default, the clipping value is set to `step**0.25`, which aligns with the theory to ensure the convergence.
We observe that the clipped ADOPT works much more stably than the original one, so we recommend to use it over the unclipped version.
If you want to reproduce the behaivior of the original version, you should set `clip_lambda = None`.

## Requirements

ADOPT requires PyTorch 2.5.0 or later.

## Usage

You can use ADOPT just like any other PyTorch optimizers by copying `adopt.py` to your project.

When you replace the `Adam` optimizer to our `ADOPT`, you should just replace the optimizer as follows:

```python3
from adopt import ADOPT
# optimizer = Adam(model.parameters(), lr=1e-3)
optimizer = ADOPT(model.parameters(), lr=1e-3)
```

When you are using `AdamW` as a default optimizer, you should set `decouple=True` for our `ADOPT`:

```python3
# optimizer = AdamW(model.parameters(), lr=1e-3)
optimizer = ADOPT(model.parameters(), lr=1e-3, decouple=True)
```

## Citation
If you use ADOPT in your research, please cite the paper.
```text
@inproceedings{taniguchi2024adopt,
 author={Taniguchi, Shohei and Harada, Keno and Minegishi, Gouki and Oshima, Yuta and Jeong, Seong Cheol and Nagahara, Go and Iiyama, Tomoshi and Suzuki, Masahiro and Iwasawa, Yusuke and Matsuo, Yutaka},
 booktitle = {Advances in Neural Information Processing Systems},
 title = {ADOPT: Modified Adam Can Converge with Any β2 with the Optimal Rate},
 year = {2024}
}
```

## License
[Apache 2.0](./LICENSE)
zerpy 1.0.0
🔗 Package Guide On https://github.com/MohamedLunar/zerpy
Requires Python: >=3.10

# ZerPy

ZerPy is a simple Python library for managing databases and environment variables. 

## Features:
- Connect and manage databases.
- Load and set environment variables from a `.env` file.
- Simple API for interacting with data and environments.

## Installation

To install ZerPy, run the following command:

```bash
pip install zerpy
```
dimbridge 0.2.1
DimBridge: Interactive Explanation of Visual Patterns in Dimensionality Reductions with Predicate Logic

# dimbridge

A Jupyter lab widget for interpreting visual patterns in dimensionality reduction plots

Based on the work:
[DimBridge: Interactive Explanation of Visual Patterns in Dimensionality Reductions with Predicate Logic
](https://arxiv.org/abs/2404.07386)

## Example
```
```
See details in [example.ipynb](./example.ipynb)


## Installation

- install jupyter lab: [[JupyterLab]](https://jupyter.org/install)

- Install DimBridge

```sh
pip install dimbridge
```

- Enable widgets extension
jupyter labextension enable widgetsnbextension

## Development installation

Create a virtual environment and and install dimbridge in *editable* mode with the
optional development dependencies:

```sh
python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"
```

You then need to install the JavaScript dependencies and run the development server.

```sh
npm install
npm run dev
```

Open `example.ipynb` in JupyterLab, VS Code, or your favorite editor
to start developing. Changes made in `js/` will be reflected
in the notebook.
wrts 0.7.0
A small lil library for using the WRTS API
Requires Python: <4.0,>=3.10

# WRTS.py (or wrts or wrtsapi)
*renaming wrts to studygo is like the rebranding of twitter to X*

No docs *yet*.

oh yeah btw disclaimer: not my responsibility if you do something dumb dumb

## TODO
[ ] Add "PublicSession" class
[ ] Add functions for changing account settings
[ ] Add support for Groups
[ ] Add support for Books
[ ] Add more exercise types
[ ] Parse more objects
[ ] Make documentation
vlsirtools 7.0.0
Tools for the Vlsir IC Design Schema
Requires Python: <3.13,>=3.7


# Vlsir Tools 

Python-based tools and utilites for working with the Vlsir IC design schema. 

## Netlisting 

FIXME! Details here. 

## Spice-Class Simulation 

VlsirTools includes drivers and result-parsers for popular spice-class simulation engines including: 

```python 
class SupportedSimulators(Enum):
    """Enumerated, Internally-Defined Spice-Class Simulators"""

    SPECTRE = "spectre"
    XYCE = "xyce"
    NGSPICE = "ngspice"
```

The primary entry-point for simulation is `vlsirtools.spice.sim`. By default, `sim` runs your chosen simulator in parallel over the list of `SimInputs` provided as `inp`.

```python
def sim(
    inp: OneOrMore[vsp.SimInput], opts: Optional[SimOptions] = None
) -> OneOrMore[SimResultUnion]:
```

The `sim` function takes as input one or more `vlsir.spice.SimInput`s and a set of simulation options (`vlsirtools.spice.SimOptions`), and returns one of two result-types depending on its input `options`.

```python
class ResultFormat(Enum):
    """Enumerated Result Formats"""

    SIM_DATA = "sim_data" 
    VLSIR_PROTO = "vlsir_proto" 
```

The `VLSIR_PROTO` result-format returns a `vlsir.spice.SimResult` object, which is a protobuf-encoded representation of the simulation results. The `SIM_DATA` format instead uses the types defined in `vlsirtools.spice.sim_data`, a python-native combination of dataclasses and numpy arrays. The former is generally more convenient for sharing with other programs, and the latter for further in-Python processing. 

### Simulator and Analysis Support

Each spice-class simulator includes its own netlist syntax and opinions about the specification for analyses. 
The `vlsir.spice` schema  

| Analysis             | Spectre            | Xyce               | NgSpice     |
| -------------------- | ------------------ | ------------------ | ------------------ |
| Op                   | :white_check_mark: | :white_check_mark: | :white_check_mark: |
| Dc                   | :white_check_mark: | :white_check_mark: | |
| Tran                 | :white_check_mark: | :white_check_mark: | :white_check_mark: |
| Ac                   | :white_check_mark: | :white_check_mark: | :white_check_mark: |
| Noise                |                    |                    | :white_check_mark: |
| Sweep                |  |  |  |
| Monte Carlo          |  |  |  |
| Custom               |  |  |  |
aladeen-media-indexer 0.2.0
A package for indexing news media articles
Requires Python: <4.0,>=3.12

# aladeen-media-indexer

Temperature index for news media


```sh
poetry env use python3.12
poetry install
source .envrc
```

## run demo

```sh
export DATABASE_URL=postgres://...
poetry run streamlit examples/app.py
```
ezzat223_health_indices 0.0.1
A unified collection of health indices and indicators eg: bmi, bai ...
Requires Python: <4.0,>=3.11
Keywords: health-indices, health-indicators, bmi, bodymass index, bai, birth-rate, jcharistech

# No more Dependency hell!
- Creates virtual environments.
- Manages dependencies.
- Publish packages to PyPI.

- You define everything in the pyproject.toml file.

## Commands
----------------
- To create a new project using it: >`poetry new <project-name>`
- Create a new project with the src directory: >`poetry new <project-name> --src`
- To init the pyproject.toml only: >`poetry init`
- Check everything is correct: >`poetry check`

***Packages***
- Add new package from cli (This will add it to current pyproject.toml file) and installs it in the venv:
>`poetry add <package-name>`
- Specify the version of the package: >`poetry add <package-name>@<version>`
- Add a package for dev only: >`poetry add <package-name> --group=dev`
- If you changed any package's version from the file not cli (update lock): >`poetry update`

- Show all packages: >`poetry show`
- Show a specific package: >`poetry show <package-name>`
- Remove a package: >`poetry remove <package-name>`

- Now to create a venv and install all specified packages: >`poetry install`
- Install without dev dependencies: >`poetry install --without dev`
- Install ONLY dev dependencies: >`poetry install --with dev`

------------
***VENV***
- To make your venv be in current working directory: >`poetry config virtualenvs.in-project true`
- Open a shell or activate the venv: >`poetry shell`
- Exit the shell: >`exit`
- Deactivate the virtualenv: >`deactivate`
- Get env info: >`poetry env info`
- List envs: >`poetry env list`
- Remove a venv: >`poetry env remove <venv-name>`
- Select a specific python version (You must have that version's exe): >`poetry env use <version>`

- If you're not in the venv and wanna execute a command using it: >`poetry run <command`

-----------------
***Versioning***
- Pump major version: >`poetry version major`
- Pump minor version: >`poetry version minor`
- Pump patch version: >`poetry version patch`

---------------------------
***Publish the package***
- First configure it: >`poetry config repositories.test-pypi https://test.pypi.org/legacy`
- Get a token and add it to the configurations: >`poetry config pypi-token.<token-name> <token>`
- Build: >`poetry build`
- Publish: >`poetry publish -r <token-name>`

---------------
***export***
- Export packages to a requirements.txt file: >`poetry export -f requirements.txt --output requirements.txt`
- Include dev or any group packages too:
>`poetry export -f requirements.txt --output requirements.txt --with <group-name>`
- By default, Poetry exports dependencies with hashes for security. If you want to exclude hashes:
>`poetry export -f requirements.txt --without-hashes --output requirements.txt`