semvec/pypi-packages huggingface dataset:
delta-library 0.0.2
A package for modelling options and option portfolios.
Requires Python: >=3.8

The delta_library is a python package used for modelling options and 
option strategies. It contains classes for Call and Put options, as well as
a class for a portfolio of options. 

The Call and Put classes can be initialized using either days to expiration or
a date of expiration. Moreover the Call and Put classes can be initialized using
either the option price or the implied volatility. 

The option and portfolio classes contain methods for calculating the
delta, gamma, vega, theta, and rho of the option or portfolio. These can also
be graphed and plotted using the included methods. 

Calling help() will provide more information on the classes and methods.

This project is licensed under the GNU General Public License v3.0. See the LICENSE file for details.
lottie-inline 0.1.3
A tool to inline images in Lottie JSON files
Requires Python: >=3.6

# Lottie Inline Tool

A simple tool to inline images in Lottie JSON files.

## Installation

```bash
$ pip install lottie-inline
```
## Usage

Basic usage:

```bash
$ lottie-inline /path/to/input-lottie-file.json /path/to/output-lottie-file.json
```

Limit the size of the images to be inlined to 100KB:

```bash
$ lottie-inline /path/to/input-lottie-file.json /path/to/output-lottie-file.json --max-size=100
```

## Details

The tool will inline all images in the Lottie JSON file and save the result to the output file.

transform: 

```json
{
  "assets": [
    {
      "id": "image_0",
      "w": 500,
      "h": 500,
      "u": "images/",
      "p": "image.png",
      "e": 0
    },
  ],
}
```

to: 

```json
{
  "assets": [
    {
      "id": "image_0",
      "w": 500,
      "h": 500,
      "u": "",
      "p": "data:image/png;base64,...",
      "e": 1
    },
  ],
}
```

## License

MIT
se3_group 0.1.3
Functions for SE(3) transformations.
Requires Python: <4.0,>=3.13

# se3_group
Functions for the Lie Algebra group SE(3)

$$ SE(3) =
\begin{bmatrix}
    R_{11} & R_{12} & R_{13} & t_1 \\
    R_{21} & R_{22} & R_{23} & t_2 \\
    R_{31} & R_{32} & R_{33} & t_3 \\
    0 & 0 & 0 & 1
\end{bmatrix} $$

where:
- \( $\mathbf{R} \in SO(3) $\) is the **rotation matrix**.
- \( $\mathbf{t} \in \mathbb{R}^3 $\) is the **translation vector**.

This representation is commonly used in **robotics and computer vision** for rigid body transformations.

<p align="center" width="80%">
    <img width="500" alt="Screenshot 2025-03-31 at 9 37 41 AM" src="https://github.com/user-attachments/assets/15d5f56c-32f8-4e18-bb05-bf84c1b48fdc" />
</p>


## Install
To install the library run: `pip install se3_group`

## Development
0. Install [Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer)
1. `make init` to create the virtual environment and install dependencies
2. `make format` to format the code and check for errors
3. `make test` to run the test suite
4. `make clean` to delete the temporary files and directories
5. `poetry publish --build` to build and publish to https://pypi.org/project/se3_group


## Usage
```
"""Basic docstring for my module."""

import matplotlib.pyplot as plt
import numpy as np
from loguru import logger

from se3_group import se3


def main() -> None:
    """Run a simple demonstration."""
    pose_0 = se3.SE3(
        xyz=np.array([0.0, 0.0, 0.0]),
        rot=np.eye(3),
    )
    pose_1 = se3.SE3(
        xyz=np.array([[2.0], [4.0], [8.0]]),
        roll_pitch_yaw=np.array([np.pi / 2, np.pi / 4, np.pi / 8]),
    )

    logger.info(f"Pose 1: {pose_0}")
    logger.info(f"Pose 2: {pose_1}")

    fig = plt.figure()
    ax = fig.add_subplot(111, projection="3d")
    pose_0.plot(ax)
    pose_1.plot(ax)

    for t in np.arange(0.0, 1.01, 0.1):
        pose_interp = se3.interpolate(pose_1, pose_0, t=t)
        pose_interp.plot(ax)
        logger.info(f"Interpolated Pose at t={t:.2f}: {pose_interp}")

    plt.axis("equal")
    ax.set_xlabel("x-axis")
    ax.set_ylabel("y-axis")
    ax.set_zlabel("z-axis")
    plt.tight_layout()
    plt.show()


if __name__ == "__main__":
    main()

```