semvec/pypi-packages huggingface dataset:
miniacd 0.1.4
Approximate convex decomposition of 3D meshes
Requires Python: >=3.9

# miniacd

<p>
    <a href="https://github.com/kylc/miniacd/blob/main/LICENSE-MIT">        <img alt="MIT"    src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
    <a href="https://github.com/kylc/miniacd/blob/main/LICENSE-APACHE">     <img alt="Apache" src="https://img.shields.io/badge/license-Apache-blue.svg"></a>
    <a href="https://github.com/kylc/miniacd/actions/workflows/ci.yaml">    <img alt="ci"     src="https://github.com/kylc/miniacd/actions/workflows/ci.yaml/badge.svg"></a>
    <a href="https://github.com/kylc/miniacd/actions/workflows/python.yaml"><img alt="python" src="https://github.com/kylc/miniacd/actions/workflows/python.yaml/badge.svg"></a>
    <a href="https://pypi.org/project/miniacd/">                            <img alt="PyPI"   src="https://img.shields.io/pypi/v/miniacd.svg"></a>
</p>

**miniacd** decomposes watertight 3D meshes into convex components which aim to be a good approximation of the input shape. It is a compact and high performance implementation of the CoACD algorithm described by Wei et al. and implemented in the [CoACD](https://github.com/SarahWeiii/CoACD) repository.

<img width="2048" height="516" alt="image" src="https://github.com/user-attachments/assets/352be41d-1a93-4dc0-ace8-78a938e5f585" />

## Setup

Run directly with [uv](https://docs.astral.sh/uv/):

``` sh
uvx miniacd --help
```

Or, use pip to install into your local environment:

``` sh
pip install miniacd
miniacd --help
```

Or, install a prerelease version:

1. Download a recent `.whl` from [GitHub Releases](https://github.com/kylc/miniacd/releases)
2. Run `pip install miniacd<...>.whl` (replace `<...>` with the actual filename)
3. Test it: `miniacd --help`

### Building Locally

``` sh
git clone git@github.com:kylc/miniacd.git
cd miniacd

# Build the Rust library
cargo build --release

# OR build a Python wheel
pip wheel .
```

## Usage

You can use the `miniacd` command to process your mesh files. It has wide support for input and output formats, provided by [trimesh](https://trimesh.org/). A typical invocation looks like this:

``` sh
miniacd input_mesh.obj --output-dir output/ --threshold 0.1
```

If you have more specific needs, you can use miniacd as a Python library. See [cli.py](python/miniacd/cli.py) for an example. You can also access the internals by using miniacd as a Rust library.

## References

Xinyue Wei, Minghua Liu, Zhan Ling, and Hao Su. 2022. Approximate convex decomposition for 3D meshes with collision-aware concavity and tree search. ACM Trans. Graph. 41, 4, Article 42 (July 2022), 18 pages. https://doi.org/10.1145/3528223.3530103
modularsnf 0.1.0
A Python module for Smith Normal Form calculations over Z/N rings
Requires Python: >=3.10

# Smith Normal form of Integer matrices mod N (Storjohann)

This is a Python module that follows the deterministic algorithms presented in Arne Storjohann's PhD Dissertation *Algorithms for Matrix Canonical Forms* (ETH No. 13922, 2000).

It implements the Lemmas and subsequent subroutines that are necessary for calculating the SNF without exponential intermediate values.

It validates against SymPy using a known equivalence between calculating the Smith Normal form of an integer matrix, and then taking mod N, compared to solving it natively in the ring.

## Quick Start

```python
from modularsnf import smith_normal_form_mod

S, U, V = smith_normal_form_mod([[2, 4, 0],
                                  [6, 8, 3],
                                  [0, 3, 9]], modulus=36)
# S = U @ A @ V  (mod 36)
# S, U, V are plain Python list[list[int]].
```

`S` is the diagonal Smith Normal Form, `U` and `V` are unimodular
transforms over $\mathbb{Z}/N\mathbb{Z}$. The return order
`(S, U, V)` — diagonal first — follows the SymPy / SageMath convention.
Rectangular matrices are supported; `S`, `U`, `V` shapes match the
input dimensions.

A matrix is **unimodular** over $\mathbb{Z}/N\mathbb{Z}$ when
$\gcd(\det(M),\, N) = 1$, the modular analogue of $|\det(U)| = 1$
over $\mathbb{Z}$.

### Lower-level API

For direct access to `RingMatrix` objects:

```python
from modularsnf.ring import RingZModN
from modularsnf.matrix import RingMatrix
from modularsnf.snf import smith_normal_form

ring = RingZModN(12)
A = RingMatrix(ring, [[2, 4], [6, 8]])
U, V, S = smith_normal_form(A)   # note: (U, V, S) order
```

For details on the algorithm (band reduction, diagonalization, Storjohann's
lemmas), see [docs/algorithm.md](docs/algorithm.md).

## Development Workflow (modern Python)

This repository supports both standard `pip` workflows and `uv` workflows.

### Using uv

```bash
uv venv
uv sync --extra dev
uv run pytest
uv run ruff check .
```

### Using pip

```bash
python -m venv .venv
source .venv/bin/activate
pip install -e .[dev]
pytest
ruff check .
```
litellm-enterprise 0.1.32
Package for LiteLLM Enterprise features
Requires Python: !=2.7.*,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*,>=3.8

## LiteLLM Enterprise

Code in this folder is licensed under a commercial license. Please review the [LICENSE](./LICENSE.md) file within the /enterprise folder

**These features are covered under the LiteLLM Enterprise contract**

👉 **Using in an Enterprise / Need specific features ?** Meet with us [here](https://calendly.com/d/4mp-gd3-k5k/litellm-1-1-onboarding-chat?month=2024-02)

See all Enterprise Features here 👉 [Docs](https://docs.litellm.ai/docs/proxy/enterprise)
mufem 0.3.28
A finite-element framework focused on multi-physics applications.
Requires Python: <3.13,>=3.12

# mufem

**μfem** is an application-focused finite element package built on top of [mfem](https://www.mfem.org).

It provides a simple Python interface for modeling multiphysics applications including
high- and low-frequency electromagnetic phenomena, magnetohydrodynamics, thermal, and flow problems.

For more details, visit: [mufem documentation](https://www.raiden-numerics.com/mufem/) and
[mufem examples](https://github.com/Raiden-Numerics/mufem-examples).

## Installation

```sh
pip install mufem
```