semvec/pypi-packages huggingface dataset:
vllm-mock 0.0.3
Provide mock instance to test vllm without CUDA or any GPUs.
Requires Python: <4.0,>=3.10
Keywords: python

# vllm-mock

Provide a mock instance to test vLLM without CUDA or any GPUs.

- **Github repository**: <https://github.com/vkehfdl1/vllm-mock/>

# Features

- `vllm.LLM.generate` mock
- `vllm.LLM.chat` mock

# Usage

It is highly recommended to use the mock instance with `pytest-mock`.

```python
from vllm_mock import LLM
from vllm import SamplingParams

def test_vllm(mocker):
    mock_class = mocker.patch("vllm.LLM")
    mock_class.return_value = LLM(model="mock-model")

    llm = mock_class()
    sampling_params = SamplingParams(temperature=0.8, top_p=0.9, logprobs=1)
    response = llm.generate("Hello, world!", sampling_params=sampling_params)
    assert isinstance(response[0].outputs[0].text, str)

    chat_response = llm.chat([
		{"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, world!"}
    ], sampling_params=sampling_params)
    assert isinstance(chat_response[0].outputs[0].text, str)
```

# Installation

```bash
pip install vllm-mock pytest-mock
```

or in a UV environment

```bash
uv add --dev vllm-mock pytest-mock
```

## To-do List

- [ ] Mock vLLM API server
- [ ] Mock Reasoning model features
- [ ] Mock quantization features
- [ ] Mock LoRA features
- [ ] vLM models mock
- [ ] `vllm.LLM.beam_search` mock
- [ ] `vllm.LLM.embed` mock
- [ ] `vllm.LLM.classify` mock
- [ ] `vllm.LLM.encode` mock
- [ ] `vllm.LLM.reward` mock

## For Contributors

### 1. Setup Environment

First, clone a repository

```bash
git clone https://github.com/NomaDamas/vllm-mock.git
cd vllm-mock
```

Then, install the environment and the pre-commit hooks with

```bash
make install
```

This will also generate your `uv.lock` file

### 2. Run the pre-commit hooks

Initially, the CI/CD pipeline might be failing due to formatting issues. To resolve those run:

```bash
uv run pre-commit run -a
```

You can create any issue or PR to support this project. Thank you!


## Builder of this repository

- [Jeffrey](https://github.com/vkehfdl1) is a creator of this repo. Made this because he desperately needed it for his research.
- [NomaDamas](https://github.com/NomaDamas) is an AI open-source Hacker House in Seoul, Korea.

---

Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv).
ibproxy 0.1.3
A proxy service for the Interactive Brokers API
Requires Python: >=3.12

<img src="https://github.com/user-attachments/assets/f04d864a-346e-4ebd-ba71-d059e290f654">

# IBKR Proxy

![PyPI - Version](https://img.shields.io/pypi/v/ibproxy)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/ibproxy)](https://pypi.org/project/ibproxy/)
![Codecov](https://img.shields.io/codecov/c/github/datawookie/ibproxy)

## Setup

You need to have the following files in the local directory to enable the use of
the IBKR OAuth service:

- `config.yaml` and
- `privatekey.pem`.

See the `README` for the [`ibauth`](https://github.com/datawookie/ibauth) project for documentation of the `config.yaml`
content.

## Running Locally

```bash
uv sync
uv run ibproxy --debug
```

## Running on EC2

To run on an EC2 instance you'd do precisely the same thing as for running
locally. Since the proxy is configured to only answer requests from `localhost`
this will mean that requests from outside will not reach the proxy. In general
this is a good thing.

There are ways that you can expose the proxy to the outside world. For the purpose of illustration suppose that you are running the proxy on an EC2
instance at 3.218.141.190.

### NGINX

Unless you set up authentication this would definitely open up a can of worms.

### SSH Tunnel

This is a simple and secure approach. Presumably you have SSH access to the EC2
instance. Run the following on your local machine to set up an SSH tunnel to the
EC2 instance:

```bash
ssh -N -L 9000:127.0.0.1:9000 ubuntu@3.218.141.190
```

That will connect port 9000 on your local machine to port 9000 on the EC2
instance. Local requests on port 9000 will then be relayed via the secure tunnel
to the proxy on the EC2 instance.

## Development

```bash
uv sync
uv run ibproxy --debug
```

You can access the Swagger interface at http://127.0.0.1:9000/docs.

### Local IBKR Authentication Workflow

If you are testing changes to `ibauth` then you can install a local copy.

1. Add this to the end of `pyproject.toml`:

    ```
    [tool.uv.sources]
    ibauth = { path = "../ibauth", editable = true }
    ```

2. `uv lock --upgrade`
3. `uv sync`

You can also set this up in one quick move:

```bash
uv add --editable ../ibauth
```
find-unicode-executable 0.1.0a2
A Python package that provides cross-platform Unicode executable path resolution. Like Unix `which` command but better.
Requires Python: >=2

# `find-unicode-executable`

A Python package that provides cross-platform Unicode executable path resolution. Like Unix `which` command but better.

## Features

- **Compatibility** - Python 2+, Windows and Unix-like systems supported
- **Generator-based** - finds all matching executables, not just the first one
- **Thread-safe** - no global state
- **Supports multi-call binaries** - DOES NOT follow symlinks to canonical paths (that would mess up `argv[0]` passed to multi-call binaries)

## Installation

```bash
pip install find-unicode-executable
```

## Usage Example

```python
# coding=utf-8
from __future__ import print_function
from find_unicode_executable import find_unicode_executable

# Find all Python executables in resolution order
# Sample output on Linux:
# /home/user/miniconda3/bin/python3.12
# /usr/bin/python3.10
# /usr/bin/python3.10
# Sample output on Windows:
# C:\Python38\python.exe
# C:\Python27\python.exe
for executable_path in find_unicode_executable(u'python'):
    print(executable_path)
```

### Windows-Specific Features

On Windows, the package automatically handles:

- `PATHEXT` environment variable (`.exe`, `.bat`, etc.)
- Current directory checking (Windows behavior)
- Case-insensitive matching

## Comparison to Alternatives

| Feature               | find-unicode-executable | `shutil.which` | Unix `which` |
|-----------------------|-------------------------|----------------|--------------|
| Multiple results      | ✅ Yes                   | ❌ No           | ❌ No         |
| Windows PATHEXT       | ✅ Yes                   | ✅ Yes          | ❌ No         |
| Thread-safe           | ✅ Yes                   | ✅ Yes          | ❌ No         |
| Follows symlinks      | ✅ Yes                   | ❌ No           | ❌ No         |
| Current dir (Windows) | ✅ Yes                   | ❌ No           | ❌ No         |

## Why Use This Package?

1. When you need **all** matches, not just the first one
2. For consistent behavior across platforms
3. When you need proper Windows executable resolution
4. For thread-safe executable finding
5. When you want to follow symlinks to real paths

## Contributing

Contributions welcome! Please open issues or pull requests on GitHub.

## License

This project is licensed under the [MIT License](LICENSE).
holy_bible_api_python 7.0.0
Add your description here
Requires Python: >=3.14

# Holy Bible API Python Client

A Python client library for accessing the Holy Bible API with full type support.

## Installation

```bash
pip install holy_bible_api_python
```

## Usage

### Basic Usage

```python
from holy_bible_api import create_bible_api

# Create an API client
api = create_bible_api()

# Make API calls
bibles = api.get_bibles()
```

### With Type Hints

```python
from holy_bible_api import (
    create_bible_api,
    DefaultApi,
    Bible,
    BibleVerse,
    GetBiblesRes,
    GetBibleVersesRes,
)

# Create a typed API client
api: DefaultApi = create_bible_api()

# Get bibles with type hints
bibles_response: GetBiblesRes = api.get_bibles()
bible: Bible = bibles_response.data[0]

# Get verses with type hints
verses_response: GetBibleVersesRes = api.get_bible_verses(
    bible_id=bible.id,
    book=1,
    chapter=1
)
verse: BibleVerse = verses_response.data[0]
print(f"{verse.book}:{verse.chapter}:{verse.verse} - {verse.text}")
```

### Custom Host

```python
from holy_bible_api import create_bible_api

# Use a custom API host
api = create_bible_api(url="https://custom-host.com")
```

## Available Types

The following types are exported for use:

### API Classes
- `DefaultApi` - Main API client
- `ApiClient` - Low-level HTTP client
- `Configuration` - API configuration
- `ApiResponse` - API response wrapper

### Models
- `Bible` - Bible metadata
- `BibleVerse` - Bible verse data
- `AudioBible` - Audio bible metadata
- `GetBiblesRes` - Response for getting bibles
- `GetBibleVersesRes` - Response for getting verses
- `GetBibleBooksRes` - Response for getting books
- `GetBibleChaptersRes` - Response for getting chapters
- `GetAudioBiblesRes` - Response for getting audio bibles
- `GetAudioBooksRes` - Response for getting audio books
- `GetAudioChaptersRes` - Response for getting audio chapters

### Exceptions
- `OpenApiException` - Base exception
- `ApiTypeError` - Type error
- `ApiValueError` - Value error
- `ApiKeyError` - Key error
- `ApiAttributeError` - Attribute error
- `ApiException` - General API exception

## Type Checking

This package includes `py.typed` marker file for full type checking support with mypy, pyright, and other type checkers.

## License

[Your License Here]