semvec/pypi-packages huggingface dataset:
edwh-sshkey-plugin 0.1.8
plugin for adding and removing keys to servers
Requires Python: >=3.10

# edwh-sshkey-plugin

[![PyPI - Version](https://img.shields.io/pypi/v/edwh-sshkey-plugin.svg)](https://pypi.org/project/edwh-sshkey-plugin)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/edwh-sshkey-plugin.svg)](https://pypi.org/project/edwh-sshkey-plugin)

-----

**Table of Contents**

- [Installation](#installation)
- [Guide](#guide)
- [Generating new keys](#generating-new-keys)
- [Adding keys](#adding-keys-to-remote)
- [Removing keys](#removing-ssh-keys-from-a-remote-machine)
- [Listing Local/Remote Keys](#list-ssh-keys-from-a-remote-or-local-machine)
- [License](#license)

## Installation

To install all edwh related plugins
```console
uvenv install edwh[plugins,omgeving]
```

To only install edwh sshkey plugin
```console
uvenv install edwh[sshkey]
```

## Guide
### Generating new keys:
example for ubuntu@user.nl
```console
edwh sshkey.generate --message={message} --owner=ubuntu --hostname=user --goal=nl
```

possible arguments for `ew sshkey.generate`:
- **message**: REQUIRED, message to give with the generated key
- **owner**: owner of the server you are generating a key for
- **hostname**: hostname of the server you are generating the key for
- **goal**: What is the goal to use this key for, for example: 'production' or 'testing'

#### note:
you atleast need to give this function 2-3 parameters and a message else it will not work.

### Adding keys to remote
example for ubuntu@user.nl
```console
edwh sshkey.add-to-remote -H ubuntu@user.nl --keys_to_remote=owner-hostname-goal
```

possible arguments for `ew sshkey.add-to-remote`:
- **keys_to_remote**: all saved keys you want to add to the remote

### Removing SSH keys from a remote machine:
The delete_remote function is used to remove specified SSH keys from a remote machine. 
The function takes in an iterable of keys to be removed and a Connection object.

#### usage:
```console
edwh sshkey.delete-remote -H ubuntu@user.nl --keys_to_remote=owner-hostname-doel
```

possible arguments for `ew delete_remote`:
- **keys_to_remote**: An iterable of keys to be removed from the remote machine. If a string is provided, it is converted into a list with one element.

#### note:
The function retrieves all key information from the keyholder and checks if the command line key is present in the key information. 
If it is, the function retrieves the SSH key and removes it from the authorized_keys file on the remote machine.
After successfully removing the key, the function prints a success message indicating that the specified key has been removed.

### List SSH keys from a remote or local machine:
```console
edwh sshkey.list -H ubuntu@user.nl
```

#### Note:
this list all found known and unknown keys on the local or remote server.

## License
`edwh-sshkey-plugin` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
bipackage 0.2.6
Bioinformatics tools package
Requires Python: >=3.10

# BIPackage
Handles basic bioinformatics operations with a python package structure


## INSTALLATION


pip
```shell
pip install bipackage
```

pipx
```shell
pipx install bipackage
```

conda
```shell
conda env create -f env.yaml
```



## USAGE


On command line,
```shell
bip <subcommand> [params]
```
On python,
```python
import bipackage as bip

bip.function(args*,kwargs**)
```

Note that `params` are the parameters for the __subcommand__.

## TAB AUTOCOMPLETION

To enable tab autocompletion, run the following command:

bashrc (For Linux)   
run bip once and restart the shell
```shell
bip
```

add to zshrc (For MacOS)
```shell
autoload -U bashcompinit
bashcompinit
eval "$(register-python-argcomplete bip)"
```

This will enable tab autocompletion for the `bip` command.
cinx 0.0.1
Very minimal and straightforward cubic interpolation on splines in JAX. Pure differentiable JAX.
Keywords: jax, interpolation, cubic-spline, automatic-differentiation, scientific-computing

# cinx

[![tests](https://github.com/alonfnt/cinx/actions/workflows/tests.yml/badge.svg)](https://github.com/alonfnt/cinx/actions/workflows/tests.yml)
[![PyPI](https://img.shields.io/pypi/v/cinx.svg)](https://pypi.org/project/cinx/)

`cinx` is a minimal, non-nonsense library for differentiable and fast **cubic spline interpolation** in [JAX](https://docs.jax.dev/en/latest/quickstart.html).

 It's designed to be fully JAX-native, supporting GPU/TPU/CPU execution, and allowing you to backpropagate through your interpolation steps for seamless integration into your machine learning workflows.

## Usage
`cinx` provides a straightforward interp function that handles both single-variable and multi-variable interpolation.
Its pure JAX design means you can trivially use JAX transformations like `jax.vmap` for batch processing and `jax.grad` for gradient calculations.

### Basic 1D Interpolation
```python
import cinx
import jax.numpy as jnp

xp = jnp.linspace(0, 1, 5)
fp = jnp.sin(xp * jnp.pi)
x = jnp.linspace(0, 1, 100)

f = cinx.interp(x, xp, fp)
```

### Multi-variate Interpolation
```python
import jax.numpy as jnp
from cinx import interp

theta = jnp.linspace(0, 2 * jnp.pi, 5)
X_data = jnp.stack((theta, jnp.sin(theta)), axis=-1)
fp = jnp.dot(X_data, rot_matrix(jnp.pi / 4).T)

xp = jnp.linspace(0, 1, len(fp))
x = jnp.linspace(0, 1, 100)

f = interp(x, xp, fp)
```

### Batch Interpolation
```python
import jax
import jax.numpy as jnp
from cinx import interp

theta = jnp.linspace(0, 2 * jnp.pi, 5)
rot_matrix = lambda a: jnp.array([[jnp.cos(a), -jnp.sin(a)], 
                                  [jnp.sin(a), jnp.cos(a)]])
X_data = jnp.stack((theta, jnp.sin(theta)), axis=-1)

angles_batch = jnp.linspace(0, 2 * jnp.pi, 10)
fp = jnp.stack([jnp.dot(X_data, rot_matrix(a).T) for a in angles_batch], axis=0)

xp = jnp.linspace(0, 1, len(fp[0]))
x = jnp.linspace(0, 1, 100)

interp_vmap = jax.vmap(interp, in_axes=(None, None, 0))
f = interp_vmap(x, xp, fp)
```

## Installation
`cinx` can be installed from [PyPI]( https://pypi.org/project/cinx) via `pip`:

```bash
pip install cinx
```

## Citation
You don't have to, but if you use `cinx` in your research and need to reference it, please cite it as follows:

```
@software{alonso_zdyb_cinx,
  author = {Alonso, Albert and Zdyb, Frans},
  title = {cinx: Minimal Cubic Spline Interpolation in JAX},
  url = {https://github.com/alonfnt/cinx},
  version = {0.0.1},
  year = {2025}
}
```
dummy-project-swayam 0.1.0
A simple dummy project for testing trusted publishing
Requires Python: >=3.8

# Dummy Project

A simple dummy Python package for testing GitHub Actions trusted publishing to PyPI.

## Installation

```bash
pip install dummy-project-swayam
```

## Usage

Simply import the package and it will print a welcome message:

```python
import dummy_project
# Output: Welcome to dummy project!
```

You can also call the welcome function directly:

```python
from dummy_project import welcome
welcome()
# Output: Welcome to dummy project!
```

## Features

- Simple welcome message on import
- Lightweight package for testing trusted publishing
- Compatible with Python 3.8+

---
video-editor-lib 0.1.0
A composable FFmpeg-based video editing library
Requires Python: >=3.8

# 🎬 Video Editing Library

A modular, pluggable video editing library built with Python and FFmpeg. 
Supports programmatic video transformations like text (watermark) overlay and audio merging using strategy and interpreter design patterns.

---

## 🚀 Features

- Add watermark (text overlay) to videos
- Overlay audio tracks onto videos
- Process nested JSON editing instructions
- In-memory and tempfile-based FFmpeg pipelines
- Clean, extendable strategy-based architecture
- Custom command interpreter for complex video editing workflows
- Developer-friendly logging using `colorlog`

---

## 📦 Installation

### From PyPI (coming soon)
```bash
pip install video-editing-lib
```

### From source
```bash
git clone https://github.com/your-username/video-editing-lib.git
cd video-editing-lib
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
```

---

## 🧪 Testing

```bash
pytest            # all tests
pytest tests/unit         # only unit tests
pytest tests/integration  # only integration tests
```

---

## 🔧 Usage Example

```python
from video_editor import process_json_command

command = {
    "operation": "overlay",
    "left": {
        "operation": "overlay",
        "left": {
            "type": "video",
            "bytes": open("video.mp4", "rb").read()
        },
        "right": {
            "type": "text",
            "value": "Watermark Text",
            "position": "bottom"
        }
    },
    "right": {
        "type": "audio",
        "bytes": open("audio.mp3", "rb").read()
    }
}

result = process_json_command(command)

with open("output.mp4", "wb") as f:
    f.write(result["bytes"].getvalue())
```

---

## 📂 Project Structure

```
video-editing-lib/
├── video_editor/              # Main package
│   ├── __init__.py
│   ├── processor.py           # Command executor
│   ├── interpreter.py         # JSON → command parser
│   └── strategies/           # VideoEditStrategy implementations
├── tests/                    # Unit and integration tests
├── README.md
├── pyproject.toml
├── setup.py
└── requirements.txt          # Optional (for dev setup)
```

---

## 🛠️ Built With

- **Python 3.11+**
- **FFmpeg + ffmpeg-python**
- **pytest** for testing
- **colorlog** for colored logging

---

## 📜 License

MIT License © 2025 Aditya Sharma / AngelOne

---

## 🙋‍♂️ Contributing

Contributions welcome! Please submit issues or pull requests for improvements or new features.

---

## 📫 Contact

For questions or support, open a GitHub issue or reach out to itsadityasharma7124@gmail.com
PITLAKQ 1.7.8
The Pit Lake Hydrodynamic and Water Quality Model
Requires Python: >=3.9

# PITLAKQ - The Pit Lake Hydrodynamic and Water Quality Model

[PITLAKQ](http://www.pitlakq.com/) couples the models
[CE-QUAL-W2](http://www.cee.pdx.edu/w2/) and
[PHREEQC](https://water.usgs.gov/water-resources/software/PHREEQC/index.html)
and adds  new functionality to account for the pit lake requirements.
It includes the most important processes in pit lakes.
For example, several sources of acidity such as erosion or release from
submerged sediments and spatially distributed groundwater inflow help to better
represent pit lake conditions.
Furthermore, PITLAKQ can account for the effects of water treatment on water
quality.
The two-dimensional model setup with one vertical and one horizontal dimension
allows having sinks and sources with defined spatial locations.

PITLAKQ is Open Source (BSD license).
You can find the [source on GitLab](https://gitlab.com/hydrocomputing/pitlakq).
Please sign up for the [email list](http://groups.google.com/group/pitlakq-users)
to stay current with the latest news.
Please subscribe (pitlakq-users+subscribe@googlegroups.com) to get your
questions about PITLAKQ answered.

Please [contact](http://www.pitlakq.com/contact.html) us for more information.