semvec/pypi-packages huggingface dataset:
django-ssh-tunnel-proxy 1.0.4
A Django plugin that allows ssh remote tunnels.
Requires Python: >=3.6

# django-ssh-tunnel-proxy

Opens an ssh tunnel so your local development server can be accessed remotely

## Quick start
1. Install with `pip install django-ssh-tunnel-proxy`
2. Add `sshtunnelproxy` to `INSTALLED_APPS`
3. Set the settings described below
4. Start a dev-server using `python manage.py runserver`
5. Open a tunnel using `python manage.py opensshtunnelproxy`
6. Visit the URL displayed in your terminal

## Context manager
Create a temporary tunnel using the context manager
```python
from sshtunnelproxy import tunnel

with tunnel() as remote_url:
    pass  # do something
```

## Available settings
```python
SSH_TUNNEL_USER: str = ''
"""The SSH user to use for the tunnel. default: `''`"""

SSH_TUNNEL_PASSWORD: str = ''
"""The SSH password to use for the tunnel. default: `''`"""

SSH_TUNNEL_PORT_RANGE: tuple[int, int] = (24000, 24999)
"""The range of ports to use for the tunnel. default: `(24000, 24999)`"""

SSH_TUNNEL_HOST: str = ''
"""The host to tunnel to. default: `''`"""

SSH_TUNNEL_URL_GENERATOR: Callable[[int], str] = lambda port: f"http://{SSH_TUNNEL_HOST}:{port + 1}"
"""
The function to generate the tunnel URL.
Takes the remote port as an argument and returns the URL at which the tunnel can be accessed.
default: `lambda port: f'http://{HOST}:{port + 1}'`
"""
```

## Remote server
For this to work, you need a remote web server to reverse-proxy the tunneled port.

## What else
Make sure to add `SSH_TUNNEL_HOST` to your `ALLOWED_HOSTS`.  
Also, `SESSION_COOKIE_SECURE = False` must be set, or else you won't be able to log in.
robotframework-browser-tray 1.8.2
Tray icon and REPL for trying out Browser Library keywords using Chromium or Edge
Requires Python: >=3.9.0

# robotframework-browser-tray

Tray icon and REPL for trying out [Browser Library](https://robotframework-browser.org/) keywords using Chromium or Edge


**Requirements**

- NodeJS >= 18
- Windows


## Use Cases

- Execute tests incrementally using e.g. [RobotCode](https://github.com/d-biehl/robotcode)

- Test selectors in an open web page interactively


## How to use it

1. Install the package

```bash
pip install robotframework-browser-tray
```

2. Execute `browser-tray`

**Hint**: In case your environment does not allow executing browser-tray, call the Python module directly:

```bash
python -m BrowserTray
```

3. Click on the tray icon with the Chromium logo

4. Open a Terminal and execute `ibrowser`

**Hint**: In case your environment does not allow executing ibrowser, call the Python module directly:

```bash
python -m BrowserTray.ibrowser
```

### ibrowser

ibrowser allows testing selectors in an open web page interactively. 

To start it execute:

```bash
ibrowser
```

On start up it connects to a running Chromium (started using the tray icon) or Microsoft Edge (see below for instructions).

If you start a new browser while ibrowser is running, call the keyword "Connect" to connect ibrowser to it.

To exit ibrowser press `Ctrl-D`.

### Usage in a Robot Framework Test Suite

Add these lines to the Settings section of the .robot file:

```robotframework
Library       Browser
Test Setup    Connect To Browser    http://localhost:1234    chromium    use_cdp=True
```

In order to use another port execute:

```bash
browser-tray --cdp-port=XXXX
``` 


### Using Microsoft Edge

If Microsoft Edge is installed on your machine:

1. Create a Shortcut to msedge.exe with the target:

```powershell
"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --remote-debugging-port=1234 --user-data-dir=C:\Users\YOUR_USER\RFEdgeProfile
```

2. Start Edge using this shortcut

3. Execute `ibrowser`


## How it works

Selecting "Open Chromium" in the tray icon executes `site-packages/Browser/wrapper/node_modules/playwright-core/.local-browsers/chromium-XX/chrome-win/chrome.exe --remote-debugging-port=1234 --test-type`.

`ibrowser` is a batteries-included [irobot](https://pypi.org/project/robotframework-debug/) that saves time by importing Browser Library and connecting to a running Chromium or Edge.
mcp-server-generator 0.1.0
Automatically generates a full MCP server codebase (Node/Python/Java) using the validated schema, outputting modular files for CLI-based execution or Claude Desktop connection
Requires Python: >=3.7

# mcp-server_generator

Automatically generates a full MCP server codebase (Node/Python/Java) using the validated schema, outputting modular files for CLI-based execution or Claude Desktop connection.

## Features

- Supports TypeScript, Python, and Java output
- Creates tools, resources, prompts, transports
- Modular codebase with ready-to-run server
- Claude Desktop compatible structure
- SDK-compliant directory structure

## Installation

```bash
pip install mcp-server_generator
```

## Usage

```python
from mcp_server_generator import Mcp_server_generator

# Initialize the library
mcp_server_generator_instance = Mcp_server_generator()

# Use the library functions
# Example usage will be added in future versions
```

## License

MIT
Terminal-Colorify 1.1.1
A simple Python module for adding colors to text in the terminal
Requires Python: >=3.6

# Terminal-Colorify
```Terminal-Colorify``` is a simple and powerful python library to color your terminal output easily with RGB, gradients, rainbows, backgrounds, flashing text, themes, and more.

## Installation
```bash
pip install Terminal-Colorify
```

## Features

Set text color using RGB or predefined names

Set background color

Bold and underline styles

Generate random colors

Create gradient colored text

Create rainbow colored text

Flash text between two colors

Animated progress bar

Built-in themes (warning, success, info, error, etc.)

## Usage
```python
from colors import Colors
import time
# Set a named color
print(Colors.set_color(color="green", text="Green Text", bold=True, underline=True))

# Set a custom RGB color
print(Colors.set_color(rgb=(255, 0, 0), text="Custom Red"))

# Random color
print(Colors.set_color(color=Colors.random_color(), text="Random Color Text"))

# Gradient text
print(Colors.gradient_text("Gradient Text", (255, 0, 0), (0, 0, 255)))

# Rainbow text
print(Colors.rainbow_text("Rainbow Text!"))

# Flashing text
color = Colors()
color.flash_text("Flashing Text!", color1="red", color2="blue", times=5, delay=0.5)

# Progress bar
for i in range(101):
    color.progress_bar(i, color="green")
    time.sleep(0.05)
print()

# Apply a theme
print(Colors.apply_theme("success"))

# List all themes
Colors.list_themes()
```

## Available Themes

```warning``` ג€” Yellow text with red background

```info``` ג€” Cyan text

```success``` ג€” Green bold text

```error``` ג€” Red bold underline text

```neutral``` ג€” White text with gray background

```dark```, ```light```, ```ocean```, ```coolblue```, ```sunset```, ```mint``` and more

## License

##### This project is open source and available under the MIT License.