semvec/pypi-packages huggingface dataset:
biosynth-emg 0.1.0
Physics-informed synthetic EMG signal generator for prosthetic control
Requires Python: >=3.7
Keywords: emg, electromyography, synthetic-data, prosthetics, machine-learning, biomedical

# BioSynth-EMG: Physics-Informed Generative Framework for Synthetic Myoelectric Signals

A physics-based synthetic EMG signal generator for training low-latency neural networks in prosthetic control systems.

## Features

- **Biomechanical Layer**: Motor unit firing rate simulation using Poisson distribution
- **Electrical Propagation Layer**: MUAP generation with Hermite functions
- **Realistic Noise**: Gaussian noise, power line interference, and movement artifacts
- **High Performance**: Optimized for GTX 1650 (<1ms generation for 1s signal)
- **Dataset Generation**: 8-channel EMG with gesture labels and force values

## Installation

```bash
pip install -r requirements.txt
```

## Usage

```python
from biosynth_emg import BioSynthGenerator

generator = BioSynthGenerator()
data = generator.generate_dataset(num_samples=1000, duration=1.0)
```

## Paper

Based on "BioSynth-EMG: A Physics-Informed Generative Framework for Synthetic Myoelectric Signal Synthesis and Prothetic Control Benchmarking"
madmax 0.0.3
Unofficial Async Client for MAX Messenger (OneMe)
Requires Python: >=3.7

# 🎌 MadMax

> **Unofficial Async Client for MAX Messenger (OneMe platform)**  
> *Developed by [CTRLJapan](https://github.com/CTRLJapan)*

![PyPI - Version](https://img.shields.io/pypi/v/madmax?style=flat-square)
![Python](https://img.shields.io/badge/python-3.8+-blue?style=flat-square)
![License](https://img.shields.io/github/license/CTRLJapan/madmax?style=flat-square)

**MadMax** is a reverse-engineered Python library for interacting with the Russian national messenger **MAX** (backend: `oneme.ru`).  
It allows you to receive messages and events via WebSocket without using a browser.

---

## 📦 Installation

Since you are cool enough to use the command line:

```bash
pip install madmax
```

## 🚀 Quick Start
```python
import asyncio
from madmax import Client

# See "How to get credentials" below
TOKEN = "YOUR_TOKEN_HERE"
DEVICE_ID = "YOUR_DEVICE_ID"

client = Client(token=TOKEN, device_id=DEVICE_ID)

@client.event
async def on_message(message):
    print(f"[{message.sender_id}] says: {message.text}")

if __name__ == "__main__":
    client.run()
```

## 🔑 How to get credentials
Since MAX does not have an open API, you need to borrow your own session credentials from the browser.

1. Open web.max.ru in Chrome/Edge.
2. Log in to your account.
3. Open Developer Tools (**F12**).
4. Go to **Application** tab -> **Local Storage** -> https://web.max.ru.
5. Find and copy values for:
- `__oneme_auth` -> This is your **TOKEN**.
- `__oneme_device_id` -> This is your **DEVICE_ID**.

**Warning**: Do not share your token with anyone. It gives full access to your account.

## ⚠️ Disclaimer
This project is for **educational purposes only**.
- This is **not** an official client.
- Using self-bots might violate the Terms of Service of the platform.
- The author (CTRLJapan) is not responsible for any bans or limitations applied to your account.
aiofasttelethonhelper 0.1.3
Fully async and parallel file upload/download in Telethon, without blocking the event loop.
Requires Python: >=3.9
Keywords: telethon, fasttelethonhelper, aio, async, telegram, selfbot, userbot

# AIOFastTelethonHelper

Asynchronous fork of [FastTelethonhelper](https://github.com/MiyukiKun/FastTelethonHelper)  
Provides fully async and parallel file upload/download functions using `aiofiles` and non-blocking I/O.

## 📦 Installation
```bash
pip install aiofasttelethonhelper
```


## ⚙️ Usage Example
```python
from aiofasttelethonhelper.utils import print_progress_bar
from aiofasttelethonhelper import fast_download, fast_upload
from telethon import TelegramClient

client = TelegramClient("session", API_ID, API_HASH)

def custom_progress_callback(**kwargs):
  done, total = kwargs.get('done'), kwargs.get('total')
  print(f"{done}/{total}")

async def main():
  async with client:
      file_path = await fast_download(
        client=client, 
        message=message, 
        file_path="./downloads", # or ./downloads/file.txt
        progress_callback=print_progress_bar
      )

      file = await fast_upload(
        client=client,
        file_path="input.txt",
        progress_callback=custom_progress_callback
      )
      await client.send_file("me", file)
```

## ❤️ Credits
- Tulir Asokan - Original parallel transfer logic in [mautrix-telegram](https://github.com/mautrix/telegram)
- MiyukiKun - Original [helper](https://github.com/MiyukiKun/FastTelethonhelper) creator
- Lonami - Creator of the amazing [Telethon](https://github.com/LonamiWebs/Telethon) library
cuc-mcp-time-server 0.1.0
A Model Context Protocol (MCP) time server that provides current time information
Requires Python: >=3.7

# MCP Time Server

A Model Context Protocol (MCP) time server that provides current time information. This server implements the MCP protocol and offers a tool to get the current time with optional timezone support.

## Features

- Provides current time information via MCP protocol
- Supports optional timezone parameter
- Easy to install and use
- Lightweight implementation

## Installation

You can install MCP Time Server using pip:

```bash
pip install mcp-time-server
```

## Usage

### Running the Server

To start the MCP Time Server, simply run:

```bash
python -m time_server
```

Or use the command-line entry point:

```bash
mcp-time-server
```

### Using the Server

The server provides a tool called `get_current_time` that can be called via the MCP protocol.

#### Example using an MCP client:

```python
import requests
import json

# Example using JSON-RPC over HTTP
url = "http://localhost:8000"

# Request without timezone
payload = {
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
        "name": "get_current_time",
        "arguments": {}
    },
    "id": 1
}

response = requests.post(url, json=payload)
print(response.json())

# Request with timezone
payload_with_tz = {
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
        "name": "get_current_time",
        "arguments": {
            "timezone": "Asia/Shanghai"
        }
    },
    "id": 1
}

response = requests.post(url, json=payload_with_tz)
print(response.json())
```

## API Reference

### `get_current_time(timezone: Optional[str] = None)`

Get the current time.

- **Parameters:**
  - `timezone` (Optional[str]): Timezone string (e.g., "Asia/Shanghai", "America/New_York"). If not provided, uses system default timezone.

- **Returns:**
  - Formatted time string in the format: "YYYY-MM-DD HH:MM:SS.SSSSSS TIMEZONE"

- **Example:**
  - `get_current_time()` → "2023-06-15 14:30:45.123456 UTC"
  - `get_current_time("Asia/Shanghai")` → "2023-06-15 22:30:45.123456 CST"

## Configuration

The server can be configured using command-line arguments or environment variables. Refer to the documentation for more details.

## Requirements

- Python 3.7+
- pytz
- fastmcp

## License

MIT

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.