semvec/pypi-packages huggingface dataset:
sogpy 1.0.2
Convert Gaussian Splat PLY files to PlayCanvas SOG format
License: MIT
Requires Python: >=3.8
Keywords: gaussian-splatting, 3d, playcanvas, sog, ply, webp, compression

# SogPy

Convert Gaussian Splat `.ply` files to PlayCanvas `.sog` format.

> ⚠️ **Note:** This is a direct Python conversion of [splat-transform](https://github.com/playcanvas/splat-transform)'s PLY to SOG Node.js code. One-shotted with Claude Opus 4.5 — use with caution! Contributions are very welcome.

## Installation

```bash
pip install sogpy
```

## Usage

### Command Line

```bash
# Basic conversion
sogpy input.ply output.sog

# With more clustering iterations (better quality, slower)
sogpy input.ply output.sog --iterations 20
```

### Python API

```python
from SogPython import convert_ply_to_sog

convert_ply_to_sog("input.ply", "output.sog")
```

## What is SOG?

SOG (Splat Optimized Graphics) is PlayCanvas's format for Gaussian splat data. It uses:

- **WebP lossless compression** for textures
- **K-means clustering** to reduce color and scale data to 256 values
- **Morton ordering** for spatial coherence
- **Smallest-three quaternion encoding** for rotations

This typically achieves **5-6x compression** compared to raw PLY files while preserving all data including spherical harmonics.

## Features

- ✅ Full PLY format support (binary little-endian)
- ✅ Spherical harmonics (bands 1-3)
- ✅ WebP lossless compression
- ✅ 16-bit position precision with log transform
- ✅ Smallest-three quaternion compression

## Requirements

- Python 3.8+
- numpy
- scipy
- Pillow

## License

MIT
cleanpykit 0.1.0
Production-ready foundation for Python applications
License: MIT
Requires Python: >=3.10

# Clean-Py-Kit

[![Github](https://img.shields.io/badge/github-repo-green?logo=github)](https://github.com/BigPocc/clean-py-kit)
![License](https://img.shields.io/badge/license-MIT-blue.svg)
![Coverage](https://img.shields.io/badge/coverage-100%25-orange)


**Clean-Py-Kit** is a library made to easily structure python projects with a clean architecture.
It provides tools ready to use:

- Config loading from `.yaml` files (`cleanpykit.config`)
- Configurable logging (`cleanpykit.logging`)
- Dependecies injection container (`cleanpykit.di`)
- Application management with startup/shutdown hooks (`cleanpykit.app`)
- Useful utilities : `Result`, `singleton`, `lazy`, `cached`, `retry`, `timed` (`cleanpykit.utils`)

---

## Installation

From PyPI:

```bash
pip install cleanpykit
```

## Minimal Usage

```python
from cleanpykit.config import BaseConfig, load_config
from cleanpykit.logging import get_logger
from cleanpykit.di import Container
from cleanpykit.app import Application
from cleanpykit.utils import singleton, lazy

class Config(BaseConfig):
    log_level: str
    log_use_color: bool = True
    log_format: str = "default"

config = load_config(Config)

log = get_logger(
    __name__,
    level=config.log_level,
    fmt=config.log_format,
    use_color=config.log_use_color
)

container = Container()

@singleton
class Database:
    def __init__(self):
        self.url = "sqlite:///:memory:"

    @lazy
    def client(self):
        return object()

container.bind(Database)

app = Application(container)

def init_db():
    db = container.resolve(Database)
    log.info(f"DB initialized at {db.url}")

app.on_startup(init_db)

def cleanup():
    log.info("Cleanup done")

app.on_shutdown(cleanup)

def main():
    log.info("Application main running")
    db = container.resolve(Database)
    log.info(f"Database URL: {db.url}")

app.run(main)
```

---

## Principals Modules

| **Module** | **Featrues**                                                                                       |
|------------|----------------------------------------------------------------------------------------------------|
| `config`   | Load configuration from YAML files into typed dataclasses.                                         |
| `logging`  | Configurable logging with JSON and colored text formatters.                                        |
| `di`       | Simple dependency injection container for managing class instances.                                |
| `app`      | Application lifecycle management with startup and shutdown hooks.                                  |
| `utils`    | Utility decorators and classes like `Result`, `singleton`, `lazy`, `cached`, `retry`, and `timed`. |

---