semvec/pypi-packages huggingface dataset:
queuedir 1.1.0
A lightweight folder-based job queue system
License: MIT
Requires Python: >=3.9

# QueueDir

A lightweight, cross-platform folder-based job queue system. Monitors an input folder and executes a script for each file that appears.

## Installation

```bash
pip install queuedir
```

## Usage

```bash
queuedir --watch /path/to/inbox --script /path/to/process.sh
```

### Options

| Option | Short | Description | Default |
|--------|-------|-------------|---------|
| `--watch` | `-w` | Folder to monitor (required) | - |
| `--script` | `-s` | Script to execute (required) | - |
| `--done-dir` | | Destination for processed files | `{watch}/done` |
| `--failed-dir` | | Destination for failed files | `{watch}/failed` |
| `--timeout` | | Script timeout in seconds | 1200 |
| `--poll-interval` | | File stability check interval | 2 |
| `--venv` | | Path to virtual environment to activate | - |
| `--once` | | Process existing files and exit | - |
| `--verbose` | `-v` | Enable debug logging | - |

### Example

```bash
# Monitor inbox, run process.py for each file
queuedir -w ./inbox -s ./process.py -v

# Use a virtual environment for Python scripts
queuedir -w ./inbox -s ./process.py --venv /path/to/venv

# Process existing files once and exit
queuedir -w ./inbox -s ./process.sh --once
```

## How It Works

1. Files dropped into the watched folder are detected
2. QueueDir waits for the file to stabilize (no longer being written)
3. The configured script is executed with the file path as argument
4. On success (exit 0): file moves to `done/`
5. On failure (non-zero exit): file moves to `failed/`

## Virtual Environment Support

When you specify a virtual environment with `--venv`, QueueDir will:
- Set the `VIRTUAL_ENV` environment variable
- Add the venv's bin/Scripts directory to `PATH`
- Use the venv's Python interpreter for `.py` scripts
- Make all venv packages available to your scripts

You can also set the venv via the `QUEUEDIR_VENV` environment variable:
```bash
export QUEUEDIR_VENV=/path/to/venv
queuedir -w ./inbox -s ./process.py
```

## Script Requirements

Your script receives the file path as the first argument:

```bash
#!/bin/bash
filepath="$1"
echo "Processing: $filepath"
# ... do work ...
exit 0  # success
```

```python
#!/usr/bin/env python
import sys
filepath = sys.argv[1]
print(f"Processing: {filepath}")
# ... do work ...
sys.exit(0)  # success
```

## License

MIT
ssh-backchannel 1.5.0
A Python-based SSH forced-command gatekeeper for remote callbacks.
License: MIT
Requires Python: >=3.8
Keywords: automation, callback, security, ssh

# ssh-backchannel
WARNING. This is vibe coded. Review before use.

Sometimes I want to do things on my local machine from a remote machine I am ssh'd into. ssh-backchannel provides a means to do so - in a moderately secure way. It allows you to run a local command from a remote machine, while asking for confirmation from your local machine.

You must have ssh running on your machine and have an IP address addressable from another machine. This can work well if you are using a VPN or a local networing.

## Architecture
A limited ssh key is created and passed to other machines when you log in. This key can only run a command which asks you for permission before running commands. 

## Installation
You can install ssh-backchannel with pipx.

```
pipx install ssh-backchannel
```

The set up your machine and the remote machine run.

`ssh-backchannel configure`
`ssh-backchannel setup-remote user@server`

Also install backchannel on the remote macine.

## Usage
Once you have setup you macine and the remote machine you can run:

`ssh-backchannel run ls`

To run ls on your home machine.

## Alternatives and prior work
If you are happy with it you could use ssh auth forwarding and just ssh into your machine. This adds a little more security since you must approve each command.

If you just want to write to your clipboard there are tools which use OSC escape codes to send data via your terminal. The only downside is that you need to set up terminal to handle deal with this. I do not like debugging this sort of stuff.

## Caveat
This only works if your host can be reached from the remote machine and may involve openning your machine ot the internet or using a VPN / being on the same subnet. Reverse proxying would probably be the easiest fix.

It is assumed that there is only one user who consistently uses a machine.

This only with X11.

Alternatively, you could use reverse proxying in your ssh config.
UDPscope 1.0.0
Professional UDP traffic analysis and diagnostics tool
License: MIT
Requires Python: >=3.8
Keywords: network, udp, analysis, diagnostics, monitoring


# UDPScope
- UDPScope is a professional network observability and diagnostics tool for UDP traffic analysis on Linux systems. It provides comprehensive monitoring, analysis, and reporting capabilities for system administrators to diagnose UDP based applications and services.

---

## Features
- Multi method capture: Uses tcpdump, tshark, Docker container introspection, and ss (socket statistics)
- Comprehensive analysis: Packet statistics, IP analysis, temporal patterns, and threat assessment
- Network diagnostics: Automatic diagnostics when no traffic is detected
- Multiple output formats: Clear console reporting with structured data
- Enterprise safe: Designed for legitimate system administration and troubleshooting

---

## Installation

### From PyPI
```bash
pip install udpscope
```

### From Debian / APT
```bash
sudo apt install udpscope
```

### From Snap
```bash
sudo snap install udpscope
```

### From Source
```bash
git clone https://github.com/yourorg/udpscope.git
cd udpscope
pip install -e .
```

---

## Usage

### Basic usage
```bash
sudo udpscope --port 2456 --duration 60 --interface any
```

### Monitor a specific interface
```bash
sudo udpscope --port 53 --duration 30 --interface eth0
```

### Short capture for quick diagnostics
```bash
sudo udpscope --port 51820 --duration 10
```

---

## Requirements

- Python 3.8+
- Linux kernel with packet capture capabilities
- One or more of:
  - tcpdump
  - tshark
  - docker
  - ss
- Root / sudo privileges (required for packet capture)

---

## License

MIT License  
See the `LICENSE` file for details.