semvec/pypi-packages huggingface dataset:
tuitka 0.1.0
A TUI Frontend for Nuitka - The Python Compiler
Requires Python: >=3.10

# Tuitka - A TUI for Nuitka

Tuitka is a Terminal User Interface (TUI) wrapper that leverages Nuitka under the hood to compile Python applications. It aims to simplify the compilation process for developers by providing:
- **Presets** for common compilation scenarios
- **Navigable TUI** for easy configuration without memorizing command-line flags
- **Intuitive interface** that makes Python compilation accessible to all developers

## Features

### Automatic Dependency Management
- Automatically detects and handles dependencies from requirements.txt, pyproject.toml, and PEP 723 inline script metadata
- Uses `uv` for fast, isolated dependency installation
- Smart plugin detection based on imported libraries

### Splash Screen
Shows the Nuitka branding on startup
![Splash Screen](https://raw.githubusercontent.com/Nuitka/Tuitka/refs/heads/main/images/Splash_screen.png)

### Script Selection
Browse and select Python scripts to compile with an interactive file dialog
![Script Input](https://raw.githubusercontent.com/Nuitka/Tuitka/refs/heads/main/images/script_input.png)

### Settings Configuration
Configure Nuitka compilation settings and flags through an intuitive UI
![Settings UI](https://raw.githubusercontent.com/Nuitka/Tuitka/refs/heads/main/images/settings_ui.png)

## Usage

### Dependency Detection
Tuitka requires one of the following to detect your script's dependencies if it contains third party libraries:
- `requirements.txt` file
- `pyproject.toml` file  
- **PEP 723 inline metadata (preferred)**

#### PEP 723 Example (Recommended)
Add this metadata block at the top of your Python script:
```python
# /// script
# dependencies = [
#   "requests>=2.31.0",
#   "numpy==1.24.0",
#   "pandas",
# ]
# ///

import requests
import numpy as np
import pandas as pd

# Your code here...
```

### Running Tuitka

Run the TUI interface:
```bash
tuitka
```

Or compile a Python file directly:
```bash
tuitka script.py
```
casechange_wic 1.0.4
Case Change

# CaseChange

A package for changing the case of strings.

## Installation

You can install the package using pip:

```
pip install casechange_wic
```

## Usage

Here's a quick example of how to use the package:

```python
from casechange import case_change

text = "Hello World"
print(case_change(text, "snake"))  # hello_world
print(case_change(text, "kebab"))  # hello-world
print(case_change(text, "camel"))  # helloWorld
```
airena-player-client 0.1.1
Python client for interacting with the airena game server: queue for games, manage state, and submit moves.
Requires Python: >=3.12

# Airena Python Player Client

`airena-player-client` is a python package for interacting with the airena game server, allowing you to queue for games, manage game state, and submit moves programmatically.

## Features
- Queue for games and manage matchmaking
- Fetch and update game state
- Submit moves and handle game progression
- Typed models for game state and moves

## Installation

```bash
pip install airena-player-client
uv add airena-player-client
```

## Quick Start

```python
from airena_player_client import AirenaPlayerClient

client = AirenaPlayerClient()

# Enter the matchmaking queue
client.enter_queue(game_type="your_game_type_id")

# Wait for a match
client.wait_for_match()

# Main game loop
while True:
    # Wait for your next action.
	client.wait_for_next_action()
    # Exit this loop if the game is over.
	if client.is_game_over():
		break
    # Inspect the new game state
    client.state.game_state
    # Submit a move
    client.make_move({"foo": "bar"}) 

```

## Environment Configuration

You can configure the client using environment variables:

- `AIRENA_UGI_URL` — Airena game server URL
- `AIRENA_API_KEY` — Your API key

## License

MIT

## Author

Henry Jones (<henryivesjones@gmail.com>)
mm-strapi-mcp 0.1.0
An MCP server for interacting with Strapi CMS.
Requires Python: >=3.8

# Strapi MCP Server

An MCP server for interacting with Strapi CMS.

## Installation

You can install the server using pip:

```bash
pip install strapi-mcp-server
```

## Configuration

Before using the server, you need to create a configuration file at `~/.mcp/strapi-mcp-server.config.json`.

1.  Create the directory:
    ```bash
    mkdir -p ~/.mcp
    ```

2.  Create the configuration file:
    ```bash
    touch ~/.mcp/strapi-mcp-server.config.json
    ```

3.  Add your Strapi server details to the file. You can add multiple servers.

    ```json
    {
      "prodserver": {
        "api_url": "https://your-strapi-instance.com",
        "api_key": "your-strapi-api-key"
      },
      "localserver": {
        "api_url": "http://localhost:1337",
        "api_key": "your-local-api-key"
      }
    }
    ```

## Usage

Once installed and configured, you can run the server from your terminal:

```bash
strapi-mcp-server
```

This will start the MCP server, and you can then interact with it using an MCP client.
qiskit-validation-addon 0.0.2
Classify quantum circuits as Malicious or Benign using a finetuned LLM adapter.
Requires Python: >=3.8

# QASM Validator

Classify quantum circuits as "Malicious" or "Benign" using a finetuned LLM adapter.

## Installation

```bash
pip install .
```

## Usage

```python
from qiskit_validation_addon import classify_quantum_circuit

result = classify_quantum_circuit("""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
""")
print(result.label)  # "Malicious" or "Benign"
print(result.raw_response)  # Raw model output
```
petls 1.0.1
PErsistent Topological Laplacian Software: a Python Library to Compute Persistent Topological Laplacians
Requires Python: >=3.10

See [the documentation](https://benjones-math.com/software/PETLS/) for details on requirements, installation, and API usage.

# Python Dependencies

* Eigen version 3.4 or higher
* pybind11
* scipy
* numpy
* Boost

# Python installation and usage
The simplest way to install is:

``` pip install petls```

The next simplest is to clone the repository and run

``` pip install .```


After that, you're all set:
```
   $ python
   >>> from petls import Rips
   >>> import numpy as np
   >>> points = np.array([[0, 0], [0, 3], [4, 0], [4, 3]])
   >>> complex = Rips(points, max_dim=3)
   >>> complex.spectra(dim=1, a=3, b=4)
   [2.0, 2.0]

```

# C++ installation
First, make and enter the ```cpp/build``` directory.

```
   cd cpp
   mkdir build
   cd build
```

Next, we make and install the project. If you have root access:
```
   cmake ..
   sudo make all install
```

If you do not have root access (e.g. on an HPC):
```
   cmake -DCMAKE_INSTALL_PREFIX=<location> ..
   make all install
```

Usually ```CMAKE_INSTALL_PREFIX``` is something like ```~/custom_libraries/```. 

For examples of how to include the library, see the ```examples``` directory, e.g. ```examples/basic_cpp/```.

# Acknowledgements
This work was supported in part by NIH grant R35GM148196, NSF grant DMS-2052983, and MSU Research Foundation.

# Citation
If you wish to cite this work, please use the following citation:
```
@misc{jones2025petlspersistenttopologicallaplacian,
      title={PETLS: PErsistent Topological Laplacian Software}, 
      author={Benjamin Jones and Guo-Wei Wei},
      year={2025},
      eprint={2508.11560},
      archivePrefix={arXiv},
      primaryClass={math.AT},
      url={https://arxiv.org/abs/2508.11560}, 
}
```
qiskit-validation-addon-JustinWoodring 0.0.1
Classify quantum circuits as Malicious or Benign using a finetuned LLM adapter.
Requires Python: >=3.8

# QASM Validator

Classify quantum circuits as "Malicious" or "Benign" using a finetuned LLM adapter.

## Installation

```bash
pip install .
```

## Usage

```python
from qiskit_validation_addon import classify_quantum_circuit

result = classify_quantum_circuit("""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
""")
print(result.label)  # "Malicious" or "Benign"
print(result.raw_response)  # Raw model output
```