semvec/pypi-packages huggingface dataset:
getstream-plugins-openai 0.1.1
OpenAI plugin for GetStream
Requires Python: >=3.10

# OpenAI Plugin for GetStream

This package provides OpenAI integration for the GetStream plugin ecosystem.

It enables features such as:
- Real-time transcription and language processing using OpenAI models
- Easy integration with other GetStream plugins and services
- Function calling capabilities for dynamic interactions

## Installation

```bash
pip install getstream-plugins-openai
```

## Usage

```python
from getstream.plugins.openai import OpenAIRealtime

# Initialize with API key
sts = OpenAIRealtime(api_key="your_openai_api_key", voice="alloy")

# Connect to a call
async with await sts.connect(call, agent_user_id="assistant") as connection:
    # Send user message
    await sts.send_user_message("Hello, how can you help me?")

    # Request assistant response
    await sts.request_assistant_response()
```

## Function Calling

The OpenAI Realtime API supports function calling, allowing the assistant to invoke custom functions you define. This enables dynamic interactions like:

- Database queries
- API calls to external services
- File operations
- Custom business logic

### Example with Function Calling

```python
from getstream.plugins.openai import OpenAIRealtime

# Define your functions
def get_weather(location: str) -> str:
    """Get current weather for a location"""
    # Your weather API logic here
    return f"Weather in {location}: Sunny, 72°F"

def send_email(to: str, subject: str, body: str) -> str:
    """Send an email"""
    # Your email sending logic here
    return f"Email sent to {to} with subject: {subject}"

# Initialize with functions
sts = OpenAIRealtime(
    api_key="your_openai_api_key",
    voice="alloy",
    functions=[
        {
            "name": "get_weather",
            "description": "Get current weather information",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"}
                },
                "required": ["location"]
            }
        },
        {
            "name": "send_email",
            "description": "Send an email to someone",
            "parameters": {
                "type": "object",
                "properties": {
                    "to": {"type": "string", "description": "Recipient email"},
                    "subject": {"type": "string", "description": "Email subject"},
                    "body": {"type": "string", "description": "Email body"}
                },
                "required": ["to", "subject", "body"]
            }
        }
    ]
)

async with await sts.connect(call, agent_user_id="assistant") as connection:
    await sts.send_user_message("What's the weather like in San Francisco?")
    await sts.request_assistant_response()

    # The assistant can now call your functions and you can respond with results
    # await sts.send_function_call_output("call_id", "function_result")
```

## Requirements
- Python 3.10+
- openai[realtime] api
- GetStream SDK

## License
MIT
pystages 1.3
Motorized stage control library for scientific applications
Requires Python: >=3.9

# PyStages

[![Documentation Status](https://readthedocs.org/projects/pystages/badge/?version=latest)](https://pystages.readthedocs.io/en/latest/?badge=latest)

PyStages is a Python 3 library for controlling motorized stages which have a
motion controller. It has been designed for microscopy test benches automation.

The following motion controllers are currently supported (only the main features
are implemented):

- Micos Corvus Eco controller
- New Scale Technologies M3-FS focus modules (serial only)
- Newport SMC100 motion controllers
- Tic Stepper Motor controller (USB only)
- CNC Router with GRBL/GCode instructions (CNC 3018-PRO)
- PI Stages driven with Mercury Controller

The library also provides helper classes for basic vector manipulation and
autofocus computation.

## Documentation

Documentation is available on [Read the Docs](https://pystages.readthedocs.io).

## PyStages GUI

A user interface has been implemented to control the stages.

You can run it with the following command:

```bash
python -m pystages.gui
```

## Requirements

This library requires the following packages:

- [pyserial](https://pypi.org/project/pyserial/)
- [numpy](https://pypi.org/project/numpy/)
- [pyusb](https://pypi.org/project/pyusb/)
- [PyQt6](https://pypi.org/project/PyQt6/)
hephaistos 0.10.1
GPU computing framework using the Vulkan API
Requires Python: >=3.8

# Hephaistos

Hephaistos is a framework for creating GPGPU appllication running on top of the
Vulkan API, allowing it to run on all major OS and on a wide range of hardware
such as all modern AMD, Intel and NVIDIA GPUs.

The library aims to reduce the amount of boiler plate code, albeit in doing so
it might hide optimization possibility Vulkan provides.

## Dependency

To ease the building process, all external dependency are stored inside the
`external` directory. Check there for more information.

### Mac OS

Mac OS does not support Vulkan on its own, but requires a translation layer
called [MoltenVK](https://github.com/KhronosGroup/MoltenVK) and can be installed
for example via Homebrew:

```bash
brew install molten-vk
```

Since future updates to MoltenVK may enable more features without rebuilding
hephaistos, it is not included in the library itself.

## Install

There exist pre-built python packages on PyPI and may be easily installed via
pip:

```bash
pip install hephaistos
```

For some rare platforms you might need to build from sources.

There are also no pre-built libraries for C++, as the API depends on the STL
and thus has no stable ABI (i.e. you would need to create a build for each
compiler).

## Building

### C++

For building the C++ library you require:

- C++20 compatible compiler
- CMake at least version 3.18

The dependencies are located in the `external` directory.
In there is a readme file for more information.

The debug build requires the validation layers, which are part of the
[Vulkan SDK](https://www.lunarg.com/vulkan-sdk/).

Hephaistos expects the kernel/shader code to be already compiled into SPIR-V
bytecode, so you must likely also need an compiler for that. The most popular
ones are:

- [glslangvalidator](https://github.com/KhronosGroup/glslang)
- [glslc](https://github.com/google/shaderc)

See the readme inside the `examples` folder for a hint on how to use them.

### Python

There are also python bindings using
[nanobind](https://github.com/wjakob/nanobind) and
[scikit-build](https://github.com/scikit-build/scikit-build).

To build the python package you can simply run from the project's root
directory:

```bash
pip install .
```

Note that the binding relies on the C++ library and thus has the same
dependencies. The dependencies on the Python side are handled by pip.

## Learning

There are some examples provided in the `examples` directory for C++ and
in `notebooks` for Python.

## License

Hephaistos is licensed under the MIT license. See `LICENSE`. External libraries
are distributed under their own license. The ones located in `external` are
always acompanied by a copy of their license.