semvec/pypi-packages huggingface dataset:
tactigon-speech-socket 5.5.0.2
Tactigon Speech Socket perform stt over a audio stream sent by socket.
License: MIT
Requires Python: <3.9.0,>=3.8.0
Keywords: tactigon, wereable, gestures controller, human interface, voice recognition, speech recognition, voice command, stt

# Tactigon Speech Socket

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

This package enables the wearable device Tactigon Skin to stream audio to a stt middleware over a socket connection

## 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.
  * Linux: 3.8.x

## Installing

Install and update using pip:

`pip install tactigon-speech-socket`

## A Simple Example

```python

import setup_path
import logging
# from tactigon_socket import SocketClient

from tactigon_speech_socket import TSkinSpeech
from tactigon_speech_socket.models.audio import VoiceConfig

logging.basicConfig(
    filename="receive.log",
    level=logging.DEBUG
)

def main():
    voice_config = VoiceConfig(
        "deepspeech-0.9.3-models.tflite",
        "my_Scorer_file.scorer"
    )
    try:
        ts = TSkinSpeech("localhost", 50006, voice_config)
        ts.start()
    except KeyboardInterrupt:
        pass
    finally:
        ts.join()


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/)
wa-socket 0.1.7
Baileys-style WhatsApp Web socket for Python
License: MIT
Requires Python: >=3.11

# wa-socket

`wa-socket` is a Python library that provides a WhatsApp Web socket interface using a
Node.js backend powered by the Baileys library.

The goal is to let Python developers interact with WhatsApp Web **without writing Node.js code**.

---

## Features

- WhatsApp Web connection via QR code
- Session persistence (scan once, reconnect automatically)
- Python-first API
- Node.js backend managed automatically
- Suitable for scripts, services, and FastAPI apps

---

## Requirements

- **Python 3.11.9**
- **Node.js 22+**

⚠️ **Node.js 18 /20  are not  supported**  
This is due to upstream dependency constraints in Baileys.

Download Node.js 22 from:
https://nodejs.org/en/download

Verify installation:
```bash
node -v
npm -v


## How it works

`wa-socket` runs a lightweight Node.js process internally.

- Python controls everything
- Node.js is only used for WhatsApp Web (Baileys)
- Communication happens via stdin/stdout (JSON events)
- QR codes are rendered directly in the terminal

QR is rendered via Python stdout (PIPE mode). Terminal compatibility may vary by system.


## Quick Start

```python
from wa_socket import WhatsAppSocket

sock = WhatsAppSocket(session_id="default")

sock.on_message(lambda msg: print(msg))
sock.start()
sock.wait_for_connection()

sock.send_message("919XXXXXXXXX", "Hello from Python")
libffx 1.0.2
FFX - Format Preserving Encryption (NIST FFX-A2 mode of operation)
License: MIT
Requires Python: >=3.9
Keywords: cryptography, encryption, format-preserving, ffx, fpe, aes

# libffx - Format Preserving Encryption

[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A Python implementation of the FFX Mode of Operation for Format-Preserving Encryption (FPE).

Format-preserving encryption encrypts data while preserving its format. For example, a 16-digit credit card number encrypts to another 16-digit number, and a 9-digit SSN encrypts to another 9-digit number.

## Quick Start

```python
import ffx

# 128-bit key (as hex)
key = ffx.FFXInteger('2b7e151628aed2a6abf7158809cf4f3c', radix=16, blocksize=32)

# Create encrypter for decimal digits
ffx_obj = ffx.new(key.to_bytes(16), radix=10)

# Encrypt a credit card number
cc_number = ffx.FFXInteger('4111111111111111', radix=10, blocksize=16)
tweak = ffx.FFXInteger('0000000000', radix=10, blocksize=10)

encrypted = ffx_obj.encrypt(tweak, cc_number)
decrypted = ffx_obj.decrypt(tweak, encrypted)

print(f"Original:  {cc_number}")   # 4111111111111111
print(f"Encrypted: {encrypted}")   # 3847592710482695
print(f"Decrypted: {decrypted}")   # 4111111111111111
```

## API Reference

### `ffx.new(key, radix)`

Create a new FFX encrypter.

- `key`: 16-byte AES-128 key
- `radix`: Base for message alphabet (2-36)

### `FFXInteger(value, radix=2, blocksize=None)`

Represent a value in a specific radix.

- `value`: Integer, string representation, or another FFXInteger
- `radix`: Base (2-36)
- `blocksize`: Minimum output length (zero-padded)

### `FFXEncrypter.encrypt(tweak, plaintext)` / `.decrypt(tweak, ciphertext)`

Encrypt/decrypt with an optional tweak (public associated data).

## Specification

This implementation follows the [NIST FFX-A2 specification](http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/ffx/ffx-spec2.pdf):

- **Cipher**: AES-128
- **Mode**: Maximally-balanced Feistel network
- **Rounds**: 10 (constant)
- **Radix**: 2–36 (binary through alphanumeric)

## Security Considerations

- FFX is designed for format-preserving encryption of small domains
- Security depends on domain size; very small domains may be vulnerable to brute force
- Always use cryptographically random keys
- Tweaks should be unique per encryption when possible

## Links

- [GitHub Repository](https://github.com/kpdyer/libffx)
- [Issue Tracker](https://github.com/kpdyer/libffx/issues)
- [NIST FFX Specification](http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/ffx/ffx-spec2.pdf)

## License

MIT License