semvec/pypi-packages huggingface dataset:
AuroCX 1.0.6
AuroCX Python Package
Requires Python: >=3.9

# AuroCX

AuroCX is a modular Python toolkit that provides:

- Communication services (SMS, Email, Lambda integration)
- AWS helper utilities
- DynamoDB repository base classes
- ID hashing & obfuscation utilities
- URL shortening service
- Common infrastructure modules

AuroCX is designed for scalable backend systems and microservices that need
communication, storage, hashing, and AWS integrations in a consistent structure.

---

## 🚀 Features

### **Communication**
- Base communication service for message handling  
- Extendable for SMS, email, and Lambda-based messaging    

### **AWS Helpers**
- Supports AWS SSM, STS, Lambda, Dynamodb utilities  
- Simplifies common AWS operations  

### **Hashing**
- ID obfuscation using Hashids  
- Extendable hashing service  

### **DynamoDB**
- Base repository pattern  
- Reusable DynamoDB interaction wrapper  

### **URL Shortener**
- Simple URL shortening service  
- Extendable for storage-based or stateless shorteners  

---

## 📦 Installation

Once published to PyPI:

```bash
pip install AuroCX
karlternion 1.0.7
Python package for computations of rotations in 3D-space.
Requires Python: >=3.9
Keywords: Rotation, Rotations, Quaternion, Quaternions, 3D

# Quaternion
Class for quaternion calculations in python.

## Installation
Download from pypi using
`pip install karlternion`

## Example of use
To rotate a vector around and axis
```
>>> import numpy as np
>>> from karlternion import Quaternion
>>> # Make a rotation around [0, 0, 1] by 45 degree.
>>> q = Quaternion.from_axis_rotation(np.array([0, 0, 1]), np.deg2rad(45))
>>> v = np.array([1, 1, 0]) # Vector to rotate.
>>> q * v # Rotate vector.
array([0.0,  1.41421356e,  0.0])
```
To make a sequence of rotations, quaternions can be multiplied.
Consider a system where you have two rotation axes.
The first is Omega, which rotates around [0, 0, 1].
Then another axis, kappa, is mounted on the omega stage (i.e., when omega rotates, so will the kappa axis). When omega is at its origin, the kappa axis is [1, 1, 1].
```
>>> import numpy as np
>>> from karlternion import Quaternion
>>> omega = Quaternion.from_axis_rotation(np.array([0, 0, 1]), np.deg2rad(20))
>>> kappa = Quaternion.from_axis_rotation(np.array([1, 1, 1]), np.deg2rad(30))
>>> v = np.array([1, 0, 0])
>>> kappa * omega * v
array([ 0.77230395,  0.62470301, -0.1152942 ])
```
Can also convert to Euler angles,
```
>>> np.rad2deg((kappa * omega).to_euler())
array([23.53771943,  6.62059431, 38.96878306])
```
and rotation matrix,
```
>>> (kappa * omega).to_rotation_matrix()
array([[ 0.77230395, -0.54077305,  0.33333333],
       [ 0.62470301,  0.74175595, -0.24401694],
       [-0.1152942 ,  0.39668958,  0.9106836 ]])
```

Furthermore, it is also possible to do spherical interpolation, either between two quaternions (`Quaternion.slerp`) or two vectors.
```
>>> v1 = np.array([0, 0, 1])
>>> v2 = np.array([0, 1, 0])
>>> Quaternion.slerp_vector(v1, v2, 0.5)
array([0.        , 0.70710678, 0.70710678])
```
dissect.squashfs 1.12.dev1
A Dissect module implementing a parser for the SquashFS file system, commonly used in appliance or device firmware
Requires Python: >=3.10

# dissect.squashfs

A Dissect module implementing a parser for the SquashFS file system, commonly used in appliance or device firmware. For more
information, please see [the documentation](https://docs.dissect.tools/en/latest/projects/dissect.squashfs/index.html).

## Requirements

This project is part of the Dissect framework and requires Python.

Information on the supported Python versions can be found in the Getting Started section of [the documentation](https://docs.dissect.tools/en/latest/index.html#getting-started).

## Installation

`dissect.squashfs` is available on [PyPI](https://pypi.org/project/dissect.squashfs/).

```bash
pip install dissect.squashfs
```

This project decompresses LZO and LZ4 compressed file systems and can use a faster, native (Rust-based) LZO or LZ4 implementation,
instead of a slower pure Python implementation. Both implementations are provided by `dissect.util`.
Pre-build wheels are available for most common platforms and the native implementation will automatically be used if available.
In the rare case that a pre-build wheel is not available, please refer to `dissect.util` for build instructions.

## Build and test instructions

This project uses `tox` to build source and wheel distributions. Run the following command from the root folder to build
these:

```bash
tox -e build
```

The build artifacts can be found in the `dist/` directory.

`tox` is also used to run linting and unit tests in a self-contained environment. To run both linting and unit tests
using the default installed Python version, run:

```bash
tox
```

For a more elaborate explanation on how to build and test the project, please see [the
documentation](https://docs.dissect.tools/en/latest/contributing/tooling.html).

## Contributing

The Dissect project encourages any contribution to the codebase. To make your contribution fit into the project, please
refer to [the development guide](https://docs.dissect.tools/en/latest/contributing/developing.html).

## Copyright and license

Dissect is released as open source by Fox-IT (<https://www.fox-it.com>) part of NCC Group Plc
(<https://www.nccgroup.com>).

Developed by the Dissect Team (<dissect@fox-it.com>) and made available at <https://github.com/fox-it/dissect>.

License terms: AGPL3 (<https://www.gnu.org/licenses/agpl-3.0.html>). For more information, see the LICENSE file.
hdsemg-pipe 0.2.0
hdsemg-pipe package
Requires Python: >=3.7

<div align="center">
<br>
  <img src="hdsemg_pipe/resources/icon.png" alt="App Icon" width="100" height="100"><br>
    <h2 align="center">🧠 hdsemg-pipe</h2>
    <h3 align="center">HDsEMG Workflow Manager</h3>
</div>

hdsemg-pipe is a Python-based application for processing HD-sEMG (High-Density Surface Electromyography) data. It provides a user-friendly interface for managing and analyzing HD-sEMG recordings.

## Documentation

The full documentation for hdsemg-pipe is available at:

📚 **[Usage Documentation](https://johanneskasser.github.io/hdsemg-pipe/)**

This includes detailed guides on installation, usage, and contributing to the project.

## Installation

In order to install hdsemg-pipe, follow the instructions in the [installation guide](https://johanneskasser.github.io/hdsemg-pipe/latest/installation/).

### Quick Installation

1. Create a virtual environment (recommended):

```bash
    # Create a virtual environment
    python -m venv venv
    
    # Activate the virtual environment
    # On Windows:
    venv\Scripts\activate
    # On Unix or MacOS:
    source venv/bin/activate
```

2. hdsemg-pipe is available as a Python package and can be installed via pip:

```bash
  pip install hdsemg-pipe
```

3. After the installation, you can run the application using from the command line:

```bash
  hdsemg-pipe
```


## Features

- 📁 File management and preprocessing
- 🔗 Grid association and ROI definition
- 🎚️ Channel selection and decomposition result visualization
- ⚡️ Integration with external tools like openhdemg
litgen 0.22.0
litgen, aka "Literate Generator", an automatic python bindings generator for humans who like nice code and APIs, based on srcML (https://srcml.org)
Requires Python: >=3.10
Keywords: bindings, c++, code, cpp, generator, pybind11, srcml

![Pip](https://github.com/pthom/litgen/workflows/pip/badge.svg)


# litgen - Literate Generator

**litgen** is an automatic Python bindings generator designed for developers who appreciate clean, well-documented, and discoverable code and APIs.

It simplifies the process of creating Python bindings for C++ libraries using [pybind11](https://pybind11.readthedocs.io/en/stable/) or [nanobind](https://nanobind.readthedocs.io), and generating bindings that are easy to use, properly documented, and fully integrated into Python IDEs.

For a full guide on how to use litgen, see the [documentation](https://pthom.github.io/litgen/).

## Key Features
- Automatically generates Python bindings for C++ libraries.
- Generates fully documented and discoverable Python code, ensuring smooth interaction for end users.
- Provides IDE-friendly bindings with accurate function signatures and auto-completion.
- Works as a C++ transformation and refactoring tool, useful for various workflows.

## Documentation

To dive deeper into how litgen works, check out the [full documentation](https://pthom.github.io/litgen/).

## Battle-Tested
Though relatively new (released in 2022), litgen has been extensively tested on over 20 different libraries, totaling more than 100,000 lines of code. It is the main engine behind the Python bindings for the popular [Dear ImGui Bundle](https://github.com/pthom/imgui_bundle).

## Keep in Touch

We’d love to hear about how you're using litgen! If you are using it, please consider [sharing your experience and insights](https://github.com/pthom/litgen/discussions).

## Help the Project

If litgen has made a difference for you—especially in a commercial or research setting—please consider [making a donation](https://www.paypal.com/donate/?hosted_button_id=SHJ68RVDKURZA). Your support helps keep the project alive and growing. Every contribution, no matter the size, is greatly appreciated!


## Contributions

Contributions are welcome! If you'd like to report a bug, suggest a feature, or submit a pull request, please visit our [GitHub issues page](https://github.com/pthom/litgen/issues). See the developer documentation inside [Build.md](Build.md)

**Notable contributors:**
* Many thanks to [@davidlatwe](https://github.com/davidlatwe) for his contributions to the nanobind support in litgen!

## License

litgen is published under the [GNU General Public License, version 3](https://raw.githubusercontent.com/pthom/litgen/main/LICENSE.txt). Code generated by litgen is **not** subject to GPL, allowing you to freely use it in your projects.