semvec/pypi-packages huggingface dataset:
pytran 0.1.1
Translator, free, and alot of language are supported

<p align="center">
  <img src="https://img.shields.io/badge/d9c-PyPI-red" alt="Version Badge">
  <img src="https://img.shields.io/badge/pytran:%20Python%20translating%20library.-8A2B295" alt="Description Badge">
  <a href="https://badge.fury.io/py/pytran">
    <img src="https://badge.fury.io/py/pytran.svg" alt="PyPI version">
  </a>
  <br>
  <a href="https://github.com/kkkik">
    <img src="https://img.shields.io/badge/GitHub-Profile-black?logo=github" alt="GitHub Profile">
  </a>
  <a href="https://t.me/TastyCode">
    <img src="https://img.shields.io/badge/Report%20Issues-Telegram-blue?logo=telegram" alt="Report Issues">
  </a>
</p>

[!!]**Python Translate Library**
## Installing on Terminal, or CMD
```bash
pip install pytran==0.1.1
```
Import: from pytrans import translate

# Automatic identification of the text in the language, and translate.
`print(translate("How are you?", to_lang="ar"))` 

# Translate with from and to.
`print(translate("Bonjour", from_lang="fr", to_lang="en"))`
<br><br>
<p align="center">
  <img src="https://img.shields.io/badge/Made%20with-%20❤️%20by%20kkkik-blue?style=flat&logo=heart" alt="Made with love">
</p>
libfoot 0.0.1
simple tool to summarize the footprint of a python package
Requires Python: >=3.8

# `libfoot`

[![PyPI](https://img.shields.io/pypi/v/libfoot)](https://pypi.org/project/libfoot/)
[![Python Versions](https://img.shields.io/pypi/pyversions/libfoot)](https://pypi.org/project/libfoot/)
[![Tests](https://github.com/zzstoatzz/libfoot/actions/workflows/test.yml/badge.svg)](https://github.com/zzstoatzz/libfoot/actions/workflows/test.yml)
[![Lint](https://github.com/zzstoatzz/libfoot/actions/workflows/lint.yml/badge.svg)](https://github.com/zzstoatzz/libfoot/actions/workflows/lint.yml)
[![License](https://img.shields.io/github/license/zzstoatzz/libfoot)](https://github.com/zzstoatzz/libfoot/blob/main/LICENSE)

a tool for analyzing the footprint of a Python package, written in Rust with python bindings via [`pyo3`](https://github.com/pyo3/pyo3)

## installation
Add `libfoot` to your project:
```bash
uv add libfoot
```

## usage

if you have `uv` installed, you don't need a static installation of `libfoot`:

```bash
uvx libfoot analyze pydantic -v 2.11.1
```

### CLI

libfoot provides a command-line interface for easy access to its functionality:

```bash
# analyze a package
libfoot analyze requests

# specify a version
libfoot analyze requests -v 2.31.0 

# get package metadata
libfoot metadata requests

# output in JSON format
libfoot analyze requests --json
```


### python interface

```python
from libfoot import analyze_package, get_pypi_metadata

# analyze a package
result = analyze_package("requests", "2.31.0")
print(f"Total size: {result['total_size']} bytes")
print(f"File count: {result['file_count']}")

# get package metadata
metadata = get_pypi_metadata("requests", "2.31.0")
print(f"Summary: {metadata['summary']}")
```

## development

To build from source:

```bash
git clone https://github.com/zzstoatzz/libfoot
cd libfoot
uv sync
```

I use [`just`](https://github.com/casey/just) as a command runner:

```bash
# build the project
just build

# run tests (builds beforehand automatically)
just test

# typecheck the project
just typecheck

# run the demo
just demo
```
## license

[MIT License](LICENSE)

## feedback

If you have any feedback, please [open an issue](https://github.com/zzstoatzz/libfoot/issues) or [create a discussion](https://github.com/zzstoatzz/libfoot/discussions).
malloy-mcp-server 0.1.1
MCP server for Malloy queries
Requires Python: >=3.11
Keywords: malloy, mcp, query, server

# Malloy MCP Server

An MCP server implementation for executing Malloy queries and managing Malloy resources.

## Features

- Execute Malloy queries via MCP
- Access Malloy project, package, and model metadata
- Robust error handling with detailed context
- Comprehensive test coverage
- Type-safe implementation

## Installation

```bash
# Install using uv (recommended)
uv pip install malloy-mcp-server

# Or using pip
pip install malloy-mcp-server
```

## Usage

### Starting the Server

```python
from malloy_mcp_server import mcp

# Run the server
if __name__ == "__main__":
    mcp.serve()
```

### Configuration

The server can be configured using environment variables:

| Variable | Description | Default |
|----------|-------------|---------|
| `MALLOY_PUBLISHER_ROOT_URL` | URL of the Malloy Publisher API | `http://localhost:4000` |

Example:
```bash
# Set the publisher URL
export MALLOY_PUBLISHER_ROOT_URL="http://malloy-publisher:4000"

# Run with custom configuration
python -m malloy_mcp_server
```

### Executing Queries

The server provides an MCP tool for executing Malloy queries:

```python
from malloy_mcp_server import ExecuteMalloyQueryTool

# Example query execution
result = await ExecuteMalloyQueryTool(
    query="select * from users",
    model_path="my_package/users"
)
```

### Accessing Resources

The server provides the following resource endpoints:

- `malloy://project/home/metadata` - Project metadata
- `malloy://project/home/package/{package_name}` - Package metadata
- `malloy://project/home/model/{model_path}` - Model metadata

## Development

### Setup

1. Clone the repository:
```bash
git clone https://github.com/namabile/malloy-mcp-server.git
cd malloy-mcp-server
```

2. Install dependencies:
```bash
uv pip install -e ".[dev]"
```

### Running Tests

```bash
# Run all tests
pytest

# Run with coverage
pytest --cov=malloy_mcp_server
```

### Code Quality

The project uses:
- `black` for code formatting
- `mypy` for type checking
- `ruff` for linting

Run quality checks:
```bash
black .
mypy .
ruff check .
```

## Error Handling

The server provides detailed error handling with context:

```python
from malloy_mcp_server.errors import QueryExecutionError

try:
    result = await ExecuteMalloyQueryTool(...)
except QueryExecutionError as e:
    print(f"Error: {e.message}")
    print("Context:", e.context)
```

## Architecture

The server is built on:
- FastMCP for the MCP server implementation
- Malloy Publisher Client for Malloy interactions
- Pydantic for data validation

Key components:
- `server.py` - Core server implementation
- `tools/query_executor.py` - Query execution tool
- `errors.py` - Error handling utilities

## Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests for new functionality
5. Submit a pull request

## License

MIT License - see LICENSE file for details
nebulae 0.6.27
A deep learning framework based on PyTorch and prevalent image processing libraries. It aims to offer a set of useful tools and functions.

<p align="center">
  <img src="https://s4.ax1x.com/2022/01/03/THE0u6.png" alt="nebulae-icon.png" width = "128" height = "128" />
</p>


<h1 align="center">Nebulae</h1>

<p align="center">
  <b> A deep learning framework based on PyTorch and prevalent image processing libraries </b><br>
  It aims to offer a set of useful tools and functions.
</p>


<p align="center">
  <img src="https://img.shields.io/pypi/v/nebulae?color=blue&label=Version" alt="Version">
  <img src="https://img.shields.io/github/stars/SeriaQ/Nebulae?style=social" alt="GitHub Repo Stars">
  <img src="https://img.shields.io/badge/Made%20with-Python-blue" alt="Python">
  <img src="https://img.shields.io/badge/License-MIT-green" alt="MIT License">
</p>


------

## 🚀 Spotlight

Several frequently used features are integrated with simple interfaces.

🛠️ **Integrated Feats** - EMA module, multi-source datasets, training log plotting and timer etc.

🎯 **Simplified API** - Unified API for distributed and single-GPU training.

⚡️ **Efficiency** - Data augmentations are reimplemented using Numpy which is faster than PIL.

🧩 **High Compatibility** - Users are able to build networks using Nebulae with PyTorch seamlessly.

------

## ⚡ Quick Start

📸 **Utility**

Obtain GPU stats after some training epochs.

```python
import nebulae as neb
from nebulae import *

gu = kit.GPUtil()
gu.monitor()
for epoch in range(10):
  # --- training code --- #
gu.status()
```

[![OSFsSD.jpg](https://ooo.0x0.ooo/2025/03/16/OSFsSD.jpg)](https://img.tg/image/OSFsSD)



Automatically select unoccupied GPUs. It is useful for a shared machine. 

```python
import nebulae as neb
from nebulae import *
# select 4 GPUs with 2GB or more memory left
engine = npe(device=power.GPU, ngpu=4, least_mem=2048)
```



Find entire distributed training and test code in ./examples/demo_core.py

------

## 📦 Installation

Users can install nebulae from pip

```sh
pip install nebulae
```

For better development, building from Dockerfile is also available. Modifying the libs version and have nvidia-docker on your machine is recommended.

```sh
sudo docker build -t nebulae:std -f Dockerfile.std .
sudo docker run -it --gpus all --ipc=host --ulimit memlock=-1 nebulae:std
```

The latest version supports PyTorch1.6 and above

------

## ❤️ Support

If you find Nebulae helpful, consider giving it a ⭐ on GitHub! ▶️ https://github.com/SeriaQ/Nebulae
flask-automate-docs 0.1.0
A Flask extension for automatic API documentation generation
Requires Python: >=3.7

# Flask Automate Docs

A Flask extension that automatically generates OpenAPI (Swagger) documentation for your Flask application's routes and SQLAlchemy models.

## Features

- Automatic route documentation extraction
- SQLAlchemy model schema generation
- Type hint support for request/response schemas
- Security scheme detection
- Beautiful Swagger UI interface
- Customizable documentation settings

## Installation

```bash
pip install flask-automate-docs
```

## Quick Start

```python
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_automate_docs import AutomateDocs

app = Flask(__name__)
db = SQLAlchemy(app)

# Initialize the extension
docs = AutomateDocs(app, db)

# Enable documentation
app.config['AUTOMATE_DOCS_ENABLED'] = True
app.config['AUTOMATE_DOCS_SQLALCHEMY'] = True  # Enable SQLAlchemy model documentation

# Your routes and models here...

if __name__ == '__main__':
    app.run(debug=True)
```

Visit `/documentation` to see the Swagger UI interface, or `/api/docs` for the raw OpenAPI JSON.

## Configuration

The extension supports the following configuration options:

- `AUTOMATE_DOCS_ENABLED`: Enable/disable documentation (default: False)
- `AUTOMATE_DOCS_SQLALCHEMY`: Enable/disable SQLAlchemy model documentation (default: False)
- `AUTOMATE_DOCS_MODELS`: Specify models module or object (default: None)
- `AUTOMATE_DOCS_TITLE`: Documentation title (default: 'API Documentation')
- `AUTOMATE_DOCS_VERSION`: API version (default: '1.0')
- `AUTOMATE_DOCS_DESCRIPTION`: API description (default: 'Auto-generated API documentation')
- `AUTOMATE_DOCS_PATH`: Swagger UI path (default: '/documentation')
- `AUTOMATE_DOCS_JSON_PATH`: OpenAPI JSON path (default: '/api/docs')

## Type Hints

The extension supports Python type hints for better schema generation:

```python
from typing import List, Dict
from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    hobbies: List[str]

@app.route('/users', methods=['POST'])
def create_user(request: User) -> Dict[str, str]:
    # Your code here...
    return {"message": "User created"}
```

## Security

The extension automatically detects common security decorators:

```python
from functools import wraps

def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        # Your authentication logic here
        return f(*args, **kwargs)
    decorated_function._login_required = True
    return decorated_function

@app.route('/protected')
@login_required
def protected_route():
    return {"message": "Protected content"}
```

## License

MIT License
qtask-py 0.1.0
A Redis-based task queue library
Requires Python: >=3.7

# QTask-Py

A Redis-based task queue library for Python, designed for parallel task processing.

## Installation

```bash
pip install qtask-py
```

## Feature

- Parallel task processing
- Multiple workers per group
- Redis-based queuing system
- Task status management
- Detailed logging

## Basic Use

```python
from qtask_py import Publisher, Subscriber

# Configure the publisher
publisher = Publisher(host='localhost', port=6379)

# Post a task
publisher.publish_task(
    queue_name='WHATSAPP',
    group_name='batch1',
    data={'to': '1234567890', 'message': 'Hola mundo'}
)

# Configure the subscriber
def handle_message(data):
    print(f"Processing message: {data}")

subscriber = Subscriber(
    host='localhost',
    port=6379,
    consumers_per_group={'batch1': 3}
)

# Subscribe to a queue
subscriber.subscribe('WHATSAPP', handle_message, 'batch1')
```

## Development

### Environment Configuration

1. Clone the repository:
```bash
git clone https://github.com/rawars/qtask-py.git
cd qtask-py
```

2. Create a virtual environment:
```bash
# On macOS/Linux
python3 -m venv venv
source venv/bin/activate

# On Windows
python -m venv venv
.\venv\Scripts\activate
```

3. Install dependencies:
```bash
pip install -r requirements.txt
```

4. Install in development mode:
```bash
pip install -e .
```

### System Requirements

- Python 3.7 or higher
- Redis Server 5.0 or higher
- Redis Server running on localhost:6379 (or set host/port in the examples)

### Try the Examples

Examples are found in the directory `examples/`:
- `test_publisher.py`: Example of how to publish tasks
- `test_subscriber.py`: Example of how to process tasks with multiple workers

To run the examples, make sure you:

1. Be in the root directory of the project:
```bash
cd /ruta/a/tu/qtask-py
```

2. Have the virtual environment activated:
```bash
source venv/bin/activate  # On macOS/Linux
# or
.\venv\Scripts\activate  # On Windows
```

3. Have Redis Server running:
```bash
# Verify that Redis is running
redis-cli ping
# You should respond with "PONG"
```

4. Run the examples (in separate terminals):
```bash
# Terminal 1 - Start the subscriber
python examples/test_subscriber.py

# Terminal 2 - Run the publisher
python examples/test_publisher.py
```

If you encounter the error "No such file or directory", verify that:
1. You are in the correct directory (use `pwd` to verify)
2. The files exist (use `ls examples/` to verify)
3. The virtual environment is activated (you should see `(venv)` in your prompt)

## Documentation

For more details on usage and configuration, please visit the [full documentation](https://github.com/rawars/qtask-py).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
pycantoether 0.1.2
This is bridge between NMEA2000 and TCP server.
Requires Python: >=3.9

# The pycantoether

NMEA2000 can bus to TCP server

This is bridge between NMEA2000 and TCP server.

Features:
  - Support different NMEA2000 CAN bus adapters, base on python-can library.
    - GS-USB (Geschwister Schneider), slcan and so on.
  - Support different TCP server interface,
    - Yacht Devices RAW TCP, ydwg02

Requirements:
  - python 3.9+

## Install

```bash
pip install pycantoether
```

[Usage](docs/01.usage.md)

## Development

```bash
python3 -m venv venv
source venv/bin/activate

# Install requirements, and editable this package
pip install -e .

# Run tests
python -m pytest --cov pycantoether
```

## Run, configuration

Config usb.backend libusb1

Environment variables:
- PYUSB_BACKEND - 'libusb1', select libusb1 as backend for PyUSB.
- LIBUSB_DEBUG - debug level, 0 - 3, 0 = off, 3 = max.