semvec/pypi-packages huggingface dataset:
ux-py 0.1.3
uv-based Python App Launcher - distribute Python apps as single executables
License: MIT
Requires Python: >=3.8
Keywords: python, packaging, distribution, uv, binary

# ux

uv-based Python App Launcher - distribute Python apps as single executables.

## Features

- **Single binary distribution** - End users don't need Python or uv installed
- **Cross-compilation** - Build for Linux/Windows from macOS
- **macOS .app bundle** - Native macOS application with icon support
- **Code signing & Notarization** - Distribute through macOS Gatekeeper
- **DMG creation** - Professional macOS distribution format

## Installation

Download from [Releases](https://github.com/i2y/ux/releases)

Or build from source:
```bash
cargo install --git https://github.com/i2y/ux
```

## Quick Start

### Basic bundling
```bash
# Bundle Python app into single binary
ux bundle --project /path/to/project --output ./dist/
```

### Cross-compilation
```bash
# Build for Linux from macOS
ux bundle --target linux-x86_64 --output ./dist/

# Build for Windows from macOS
ux bundle --target windows-x86_64 --output ./dist/
```

### macOS .app bundle
```bash
# Create .app bundle
ux bundle --format app --output ./dist/

# With code signing
ux bundle --format app --codesign --output ./dist/

# With notarization (requires Apple Developer account)
ux bundle --format app --notarize --output ./dist/

# Create DMG for distribution
ux bundle --format app --codesign --dmg --output ./dist/
```

## Configuration

Add `[tool.ux]` section to your `pyproject.toml`:

```toml
[project]
name = "myapp"

[project.scripts]
myapp = "myapp.main:main"  # Entry point

[tool.ux]
entry = "myapp"            # Optional: explicit entry point
include = [                # Optional: additional files to include
  "assets/",               # Include entire directory (trailing slash)
  "config.yaml",           # Include specific file
]

[tool.ux.macos]
icon = "assets/icon.png"   # PNG auto-converted to ICNS
bundle_identifier = "com.example.myapp"
bundle_name = "My App"
```

### Included files

The bundle automatically includes:
- Package directory (detected from `[project].name`, e.g., `myapp/` or `src/myapp/`)
- `pyproject.toml`, `uv.lock`
- `README.md`, `LICENSE` (if present)

Use `[tool.ux].include` to add extra files or directories (with trailing slash)

## Supported Platforms

| Target | Cross-compile from macOS |
|--------|-------------------------|
| darwin-x86_64 | Native |
| darwin-aarch64 | Native |
| linux-x86_64 | Yes |
| linux-aarch64 | Yes |
| windows-x86_64 | Yes |

## License

MIT
blox.api 0.0.1
blox.api is an asynchronous Python wrapper for Roblox Web & Open Cloud APIs
License: MIT
Requires Python: >=3.8
Keywords: roblox, blox, ropy

`blox.api` is an asynchronous Python wrapper for Roblox Web and Open Cloud APIS.  
It provides a convenient way to interact with Roblox APIs.

### 📖 [Documentation](https://github.com/TychoTeam/blox.api-py/wiki) | [PyPI](https://pypi.org/project/blox.api) | [Supported Endpoints](https://github.com/TychoTeam/blox.api-py/blob/main/SUPPORTED.md)

## Install Latest Release (`pip`)

```sh
pip install blox.api
```

The package has been tested for Python `v3.8+`. It may not work on older versions.
tactigon-gear 5.5.2
Tactigon Gear to connect to Tactigon Skin wereable platform
License: MIT
Requires Python: >=3.12.0
Keywords: tactigon, wereable, gestures controller, human interface

# Tactigon Gear

![The tactigon team](https://avatars.githubusercontent.com/u/63020285?s=200&v=4)

This package enables the wearable device Tactigon Skin to connect to your python project using Bluetooth Low Energy.

## Architecture

Tactigon Gear environment has the following architecture:

Server is located on the cloud and it is manteined by Next Industries s.r.l.
Server has a web interface where you can handle your profile and your data (models and gestures)

Provided Tactigon Gear SDK is the implementation of Tactigon Gear environment client side

Tactigon Gear SDK is used for collecting new raw data, send the data to server,
ask server to train a model using the raw data, and download the model from server. 
Finally use the model for testing real-time gesture recognition.

![Tactigon Gear architecture definition](https://www.thetactigon.com/wp/wp-content/uploads/2023/11/Architecture_Tactigon_Gear.png "Tactigon Gear architecture definition")  

## Prerequisites
In order to use the Tactigon Gear SDK the following prerequisites needs to be observed:

* Python version: following versions has been used and tested. It is STRONGLY recommended to use these ones depending on platform.
  * Win10: 3.12.x
  * Linux: 3.12.x
  * Mac osx: 3.12.x
  * Raspberry: 3.12.x

## Installing

Install and update using pip:

`pip install tactigon-gear`

## A Simple Example

```python

import time
from tactigon_gear import TSkin, TSkinConfig, Hand, OneFingerGesture

def main():
    TSKIN_MAC = "change-me"
    tskin_cfg = TSkinConfig(TSKIN_MAC, Hand.RIGHT) # Hand.LEFT if the TSkin is wear on left hand.

    with TSkin(tskin_cfg) as tskin:
        i = 0

        while True:
            if not tskin.connected:
                print("Connecting..")
                time.sleep(0.5)
                continue

            if i > 5:
                break

            a = tskin.angle
            t = tskin.touch
            acc = tskin.acceleration
            gyro = tskin.gyro

            print(a, t, acc, gyro)

            if t and t.one_finger == OneFingerGesture.TAP_AND_HOLD:
                i += 1
            else:
                i = 0

            time.sleep(0.02)
        
if __name__ == "__main__":
    main()
```

## Links
- [Tactigon SOUL](https://github.com/TactigonTeam/Tactigon-Soul/wiki)
- [SDK](https://github.com/TactigonTeam/Tactigon-SDK)
- [Documentation](https://github.com/TactigonTeam/Tactigon-SDK/wiki)
- [Blog](https://www.thetactigon.com/blog/)