semvec/pypi-packages huggingface dataset:
funstall 0.1.7
The fun cross-platform package manager!
Requires Python: >=3.13

# Funstall

This is my own custom software installer (well, mostly it's a wrapper around
other package managers) that keeps my Linux and Mac machines up-to-date.

## Usage

**NOTE** Since this tool currently requires
[pyenv](https://github.com/pyenv/pyenv) it does not run on Windows.

### Installation

**NOTE** This tool uses [pyenv](https://github.com/pyenv/pyenv) to install
itself and other software that runs on Python.
The installer will install pyenv if it is not available.

```nu
(
  ^curl
    --silent
    --show-error
    --location
    https://raw.githubusercontent.com/hbibel/funstall/refs/heads/main/install.nu
    -o /tmp/install-funstall.nu
)
nu /tmp/install-funstall.nu  # Add flags as required
rm /tmp/install-funstall.nu
```

A link to the executable will be placed at `~/.local/bin`. Make sure this is
on your `PATH`.

### Invokation

Run `funstall --help` or `funstall <COMMAND> --help` for usage instructions.

When software running on Node.js is installed, funstall will use
[fnm](https://github.com/Schniz/fnm) to install a suitable Node.js version.
If fnm is not installed or not on the `PATH`, funstall will install it.

## Why?

I use multiple operating systems on multiple machines, requiring me to switch
between package managers (mainly pacman and brew).
My goal is to have a consistent, personal workflow no matter which machine I
use, so I need a wrapper around platform-specific package managers.

As a side note, I also don't agree with how some AUR packages are implemented,
so I'm hesitant to use `yay` on Arch.
Implementing my own installation scripts based on AUR implementations also
makes me feel safer from supply-chain attacks.

## About Sources

Funstall can pull packages using various other tools, e.g. pip or brew, which
are called "sources".
Generally the source closest to the original developer's control is selected,
e.g. PyPI or NPM are usually more directly managed by the developers, and thus
tend to be more up-to-date.
The preferred order of sources is implemented in
`funstall/installation/source_priorities.py`.

## Implementation Considerations

Initially I planned to implement this in nushell within my dotfiles.
However I started to feel uneasy with the rather simplistic typing system in
nushell as data models surpassed a certain level of complexity.
Therefore I decided to reach for another programming language.

I started this project using Python because I want to avoid writing a GitHub
action for now to distribute this project across my computers.
While I quickly realized that I cannot easily get around a build step I stuck
with Python because I'm most productive with it.
Generally I prefer compiled languages for CLI applications though so I may
**rewrite in Rust™** in the future (or in another language).

## Development

Publish a new version:

First create a PyPI API key with access to the repository.
Then save it in `.pypi-token.secret`.

```sh
uv build
uv publish --token $(cat .pypi-token.secret)
```
FreeClimb 5.3.0
FreeClimb API
Keywords: OpenAPI, OpenAPI-Generator, FreeClimb API

    FreeClimb is a cloud-based application programming interface (API) that puts the power of the Vail platform in your hands. FreeClimb simplifies the process of creating applications that can use a full range of telephony features without requiring specialized or on-site telephony equipment. Using the FreeClimb REST API to write applications is easy! You have the option to use the language of your choice or hit the API directly. Your application can execute a command by issuing a RESTful request to the FreeClimb API. The base URL to send HTTP requests to the FreeClimb REST API is: /apiserver. FreeClimb authenticates and processes your request.
nwn 0.0.22
collection of modules for working with Neverwinter Nights 1: Enhanced Edition
Requires Python: >=3.11

nwn
===

A python package with various modules for accessing Neverwinter Nights: Enhanced Edition
data formats and functionality.

Stability
---------

This package is currently in ALPHA state. API stability is not guaranteed.

Installation
------------

The package is available on PyPI and can be installed with pip:

.. code-block:: bash

    pip install nwn

Documentation
-------------

See the `documentation <https://niv.github.io/nwn.py/>`_ for usage.

License
-------

This package is licensed under the MIT license.
deltastream-connector 0.3.1
An OpenAPI client for the DeltaStream API
Requires Python: >=3.11

# deltastream-connector

A Python client library for [DeltaStream](https://deltastream.io) - a SQL streaming processing engine based on Apache Flink.

## Features

- Asynchronous API client for DeltaStream
- Support for SQL statements execution
- Streaming result sets
- File attachments for SQL queries (e.g., JAR files for UDFs)
- API Token authentication
- Python 3.11+ support

## Installation

```bash
pip install deltastream-connector
```

## Quick Start

```python
import asyncio
from deltastream.api.conn import APIConnection

# Initialize connection with API token
auth_token = os.getenv("DELTASTREAM_AUTH_TOKEN")

if not auth_token:
    raise ValueError("Environment variable 'DELTASTREAM_AUTH_TOKEN' is not set")

# Use the token to construct the DSN and create the connection
dsn = f"https://:{auth_token}@api.deltastream.io/v2"
conn = APIConnection.from_dsn(dsn)

async def main():
    # Execute SQL queries
    rows = await conn.query("SELECT 1;")
    
    # Process results asynchronously
    async for row in rows:
        print(row)

if __name__ == '__main__':
    asyncio.run(main())
```

## File Attachments

The connector provides convenient helper functions to attach files (like JAR files for UDFs) to SQL queries without manually creating blob objects.

### Simple File Attachment

```python
import asyncio
from deltastream.api.conn import APIConnection

async def main():
    conn = APIConnection.from_dsn("https://:{token}@api.deltastream.io/v2")
    
    # Create a function source with a JAR file attachment
    await conn.exec_with_files(
        "CREATE FUNCTION_SOURCE \"my_udf\" WITH ('file' = 'my_function.jar', 'description' = 'My custom UDF');",
        ["/path/to/my_function.jar"]
    )
    
    # Query function sources and get results
    rows = await conn.query_with_files("SHOW FUNCTION_SOURCES;")
    async for row in rows:
        print(f"Function: {row[0]}, Status: {row[1]}")

if __name__ == '__main__':
    asyncio.run(main())
```

### Advanced File Attachment Configuration

```python
# Custom file names and content types
await conn.exec_with_files(
    "CREATE FUNCTION_SOURCE \"advanced_udf\" WITH ('file' = 'custom_name.jar');",
    [{
        "path": "/path/to/actual_file.jar",
        "name": "custom_name.jar",
        "content_type": "application/java-archive"
    }]
)

# Multiple files
await conn.exec_with_files(
    "CREATE FUNCTION_SOURCE \"multi_file_udf\" WITH ('file' = 'main.jar', 'lib' = 'dependency.jar');",
    [
        "/path/to/main.jar",
        {"path": "/path/to/lib.jar", "name": "dependency.jar"}
    ]
)
```

## Authentication

The connector uses API token authentication. You can obtain an API token from the DeltaStream platform by running `CREATE API_TOKEN api_token_name;` using the console.

## Support

For support, please contact support@deltastream.com or open an issue on our [GitHub repository](https://github.com/deltastreaminc/deltastream-connector/issues).
whatsfly-labfox 0.3.3
Whatsapp Web wrapper in Python, without webdrivers
Requires Python: >=3.12

# WhatsFly
[![Build](https://github.com/Labfox/whatsfly/actions/workflows/build.yml/badge.svg)](https://github.com/Labfox/whatsfly/actions/workflows/build.yml)

## Just run and have fun. Just try and go fly. 

> [!NOTE]  
> There currently isn't active development, but the project is still maintained. If you want a feature, please create an issue, I'll try to implement it as soon as possible (I usually respond within 1-2 weeks).

WhatsApp web wrapper in Python. No selenium nor gecko web driver needed. 

Setting up browser driver is tricky for python newcomers, and thus it makes your code so 'laggy' while using lots of RAM.

This project originates from [cloned-doy/whatsfly](https://github.com/cloned-doy/whatsfly)

## Documentation

https://labfox.github.io/whatsfly/

## Supported machines

The library theoretically supports every machine with Go and CGo, but if the builds fail on your machine, there are pre-built binaries auto-downloaded for the following architectures:

- Linux (amd64)
- Windows (amd64)
- macOS (amd64)
- macOS (arm64)

Additionnal architectures can be added by getting a standalone build of the go module, and adding an issue/PR to add a CI job.

## Contributing
> Please report any bug or unclear behahivor; you can also submit a PR to fix it or add a new feature.
ctypes-mosquitto 0.2.0
A lightweight Python MQTT client implemented as a binding to libmosquitto via ctypes.
Requires Python: >=3.8

# ctypes-mosquitto

A lightweight Python MQTT client implemented as a thin wrapper around libmosquitto.


## Dependencies

- python3.8+
- libmosquitto1


## Installation

- pip install ctypes-mosquitto


## Usage

```python
from ctypes_mosquitto import Mosquitto


def on_message(client, userdata, msg):
    print(msg)


client = Mosquitto()
client.connect_callback_set(lambda *_: client.subscribe("#", qos=1))
client.message_callback_set(on_message)
client.connect_async("localhost", 1883)
client.loop_forever()
```

Async client example:

```python
import asyncio

from ctypes_mosquitto.aio import AIO
from ctypes_mosquitto import Mosquitto


async def main():
    async with AIO(Mosquitto()) as client:
        await client.connect("localhost", 1883)
        await client.subscribe("#", 1)
        async for msg in client.read_messages():
            print(msg)


asyncio.run(main())
```

Check out more examples in `tests` directory.


## Benchmarks

Receiving one million messages with QoS 0.

*The memory plots exclude the Python interpreter overhead (~10 MB).

![benchmark-results](./results.png)

Losers excluded:

![benchmark-results-fast](./results_fast.png)

**benchmark.csv**

```text
Module;Time;RSS
ctypes_mosq;4.44;7900
ctypes_mosq_async;8.54;14672
paho;8.74;13004
gmqtt;3.54;12136
mqttools;11.39;15716
aiomqtt;147.40;302936
amqtt;90.32;469020
```


## License

MIT
rwslib 1.2.15
Rave Web Services for Python
Requires Python: <4,>=3.8.0

rwslib
======

The Goal of this library is to provide a (programmer) friendly client library to Rave Web Services (RWS).

Philosophy
----------

rwslib provides a convenient interface to RWS without hiding the implementation details. For instance,
using rwslib you should have a simple way to request a list of studies from RWS but still be able to
get to the HTTP headers, content body etc returned by RWS.

Documentation
-------------

Documented with Sphinx. See http://rwslib.readthedocs.org/en/latest/
nextline-test-utils 0.1.3
A collection of utilities for testing Nextline packages
Requires Python: >=3.10

# Nextline Test Utils

[![PyPI - Version](https://img.shields.io/pypi/v/nextline-test-utils.svg)](https://pypi.org/project/nextline-test-utils)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/nextline-test-utils.svg)](https://pypi.org/project/nextline-test-utils)

[![Test Status](https://github.com/simonsobs/nextline-test-utils/actions/workflows/unit-test.yml/badge.svg)](https://github.com/simonsobs/nextline-test-utils/actions/workflows/unit-test.yml)
[![Test Status](https://github.com/simonsobs/nextline-test-utils/actions/workflows/type-check.yml/badge.svg)](https://github.com/simonsobs/nextline-test-utils/actions/workflows/type-check.yml)
[![codecov](https://codecov.io/gh/simonsobs/nextline-test-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/simonsobs/nextline-test-utils)

A collection of test utilities for the development of Nextline backend server and plugins.

---
aero-lang 0.0.3a0
A fast, fluid language built for lightweight systems and high-speed execution
Requires Python: >=3.7

# Aero Language

**A fast, fluid language built for lightweight systems and high-speed execution.**
_Aero lifts your code off the ground - fast compile, faster runtime._

---

## Installation
From PyPI (recommended)
```bash
pip install aero-lang
```
From source (development)
```bash
git clone https://github.com/Aero-Organization/aero-lang.git
cd aero-lang
pip install -e .
```

---

## Quick Start
Create `hello.aero`:
```aero
// Aero v0.0.2b example
name = "World"
version = "0.0.2b"

print("Hello,", name, "!")
print("Aero version:", version)
```
Run it:
```bash
aero hello.aero
```
Output:
```
Hello, World !
Aero version: 0.0.2b
```

---

## Syntax Examples
Variables & Assignment
```aero
counter = 100
pi = 3.14  // Note: only integers supported in v0.0.2b
message = "Lift off!"
```
Function Calls
```aero
print("Signle arg")
print("Multiple", "args", "supported")
```
Expressions
```aero
x = 5
y = 10
print("Sum:", x + y) // Output: Sun: 15
```
> "**NOTE**: v0.0.2b supports only **integers,** **strings,** `+`, `-`, and `print()`. Full expressions, loops, and conditionals coming in v0.0.3a!"

---
## CLI Usage
```bash
aero [file.aero]
```
Examples:
```bash
aero examples/hello.aero
aero my_script.aero
```

---
## Roadmap
| VERSION | FEATURES |
| ------- | -------- |
| v0.0.3a | `if`/`else`,`while`,booleans, comparisons |
| v0.0.4a | Functions (`fn`), return values |
| v0.1.0  | First stable preview (stdlib, file I/O) |