semvec/pypi-packages huggingface dataset:
create-mountaineer-app 0.10.1
Easily get started with a new Mountaineer project.
Requires Python: <3.14,>=3.10

![Mountaineer Header](https://raw.githubusercontent.com/piercefreeman/mountaineer/main/media/header.png)

# Project Template

CLI to setup a basic scaffolding for mountaineer. This provides a simple base project that can be generated via UV.

```bash
uv run create-mountaineer-app
```

## Installing UV

UV is a fast Python package installer and resolver, written in Rust. Follow their [install guide](https://github.com/astral-sh/uv#installation) to get started.

## Development

If you're making frequent changes in development, you can create a fresh project directory:

```bash
rm -rf test-project && uv run create-mountaineer-app --output-path test-project --mountaineer-dev-path ../
```

For local development on the CLI itself, install in editable mode:

```bash
uv pip install -e .
```
libtorrent-windows-dll 0.0.3
Required Windows OpenSSL DLLs for libtorrent
Requires Python: >=3.7

# libtorrent-windows-dll

[![Downloads](https://static.pepy.tech/badge/libtorrent-windows-dll)](https://pepy.tech/project/libtorrent-windows-dll)  [![Pypi Badge](https://img.shields.io/pypi/v/libtorrent-windows-dll.svg)](https://pypi.org/project/libtorrent-windows-dll/) 


This package exports OpenSSL dll's for libtorrent.

The noted DLL's are:
- `libcrypto-1_1-x64.dll`
- `libssl-1_1-x64.dll`

They are installed in `libtorrent` namespace to facilate the missing dll error in libtorrent. 

Solution for the [arvidn/libtorrent#7338](https://github.com/arvidn/libtorrent/issues/7338)
lsattr 2025.7.8.1
List attributes of a class

lsattr
======

List the attributes of a class in a ``repr()``-fiendly way

Example usage
-------------

.. code-block:: python

    Here be dragons...

Installation
------------

The `project <https://pypi.org/project/lsattr/>`_ is on PyPI, so simply run

.. code-block:: bash

    python -m pip install lsattr
humac-tools-library 0.1.1
A simple Python library with correlation, seasonality ,optimzedGecode,graphExplainer,detectAnomalies  plus advanced data analysis tools.
Requires Python: >=3.6

humac_tools Library
humac_tools is a simple Python library that provides a collection of functions for data analysis, feature engineering, G-code optimization, and utility operations. It includes tools for correlation analysis, seasonality detection, anomaly detection, Pareto analysis, JWT decoding, color classification, and more. This library is designed to simplify common data science and manufacturing analytics tasks.

Installation
You can install the library using pip. Run the following command in your terminal:

text
pip install humac_tools_library
Features
Correlation Analysis: Identify highly correlated and dependent features using Pearson correlation and mutual information.

Seasonality Detection: Analyze time series data for trends, seasonality, and recurring patterns (daily/hourly).

Anomaly Detection: Detect and summarize outliers in time series data.

Pareto Analysis: Identify major contributors to time loss or downtime in manufacturing data.

G-code Optimization: Optimize CNC toolpaths using nearest neighbor algorithms to reduce travel distance.

JWT Decoding: Decode JWT tokens to extract user claims.

Color Classification: Classify feature values into Green, Amber, or Red based on thresholds.

Utility Functions: Includes addition, subtraction, and greeting functions.

Usage
After installation, you can use the library in your Python scripts as follows:

python
from humac_tools import correlation, analyzeSeasonality, anomaliesDetect, paretoAnalysis, optimizedGcode

# Example: Correlation analysis
result = correlation(json_data, target_col="oee")
print(result)

# Example: Seasonality analysis
seasonality = analyzeSeasonality(json_data, target="cycletime", freq='D')
print(seasonality)

# Example: Anomaly detection
anomalies = anomaliesDetect(json_data, target_col="downtime")
print(anomalies)

# Example: Pareto analysis
pareto = paretoAnalysis(json_data, category_column="machineid", feature_name="breakdown_time")
print(pareto)

# Example: G-code optimization
optimized = optimizedGcode(raw_gcode)
print(optimized["updated_gcode"])

Contributing
If you would like to contribute to this project, please fork the repository and submit a pull request. Contributions are welcome!

License
This project is licensed under the MIT License – see the LICENSE file for details.
fakeshot 0.3.2
Generate dummy EXR files for VFX pipeline testing.
Requires Python: <3.14,>=3.10
Keywords: vfx, exr, openexr, pipeline, testing, dummy, placeholder, renders, shots

# fakeshot

A simple tool that generates dummy EXR files for VFX projects. Useful when you need placeholder renders that follow proper naming conventions.

## What it does

Creates fake EXR image files organized in the typical VFX directory structure:

```
project/scene/shot/task/version/project_scene_shot_task_version.frame.exr
```

Each EXR has the filename written in the center so you can tell what's what.

## Install

```bash
pip install fakeshot
```

Or even better
```bash
pipx install fakeshot
```

## Basic usage

Just run it and it'll create some sample files in an `./out` folder:

```bash
fakeshot
```

## Customize it

You can change most things with command line options:

```bash
fakeshot \
  --show "myproject" \
  --scene "010,020" \
  --shot "0010,0020,0030" \
  --task "comp,light" \
  --start_frame 1001 \
  --end_frame 1024
```

Or use a JSON template file:

```bash
fakeshot --template my_template.json
```

To see what a template looks like:

```bash
fakeshot --sample-template
```

### Custom naming patterns

You can change how files are organized and named using these options:

- `--path-pattern` - directory structure (default: `{show}/{scene}/{shot}/{task}/{version}`)
- `--file-pattern` - filename format (default: `{show}_{scene}_{shot}_{task}_{version}.{frame}`)

For example, if you want a flatter structure:

```bash
fakeshot --path-pattern "{show}/{shot}" --file-pattern "{shot}_{task}.{frame}"
```

This would create:

```
myproject/0010/0010_comp.1001.exr
myproject/0010/0010_comp.1002.exr
```
## Options

- `--out` - where to save files (default: ./out)
- `--show` - project name
- `--scene` - scene names (comma separated)
- `--shot` - shot names (comma separated)
- `--task` - task types (comma separated)
- `--version` - version string
- `--start_frame` / `--end_frame` - frame range
- `--width` / `--height` - image dimensions
- `--verbose` - more output
- `--file-pattern` - how to render the filename
- `--path-pattern` - how to render the path of the filename

## Why?

Sometimes you need a quick, throwable bunch of EXR files to test tools or directory structures.

The EXR files are just gray images with the filename in the middle, but they're real EXR files that should work with most tools.
mememo 1.1
Lightweight package to find the mean, median, and mode.
Requires Python: >=2.5

# mememo

![PyPI version](https://img.shields.io/badge/mememo-v1.1-5FC33B)
![Python version](https://img.shields.io/badge/python-2.5+-blue)
![Lightweight](https://img.shields.io/badge/lightweighter_than-numpy_or_statistics-red)
![Github](https://pypi-camo.freetls.fastly.net/23118282b10fb95911c44c745f183334700c10a4/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6f6e2d4769746875622d677265656e)

 The lightweight package to find the mean, median, and mode. (Hence the name MEanMEdianMOde)

---

## Benefits

- Most efficient and more lightweight than the `numpy` or `statistics` module.
- No need other 3rd-party modules to install.
- Only 3 functions.
---
#### Changelog: https://github.com/dUhEnC-39/mememo/blob/main/CHANGELOG.txt
#### Github repo: https://github.com/dUhEnC-39/mememo
## Documentation guide

## `mean()`

You can use the `mean()` function to find the mean of 2+ numbers.

```python
import mememo

a = mememo.mean([1, 2])
print(a) # Output: 1.5
```

#### Same way applies to the `median()` and `mode()` functions.

```python
a = mememo.median([1, 2])
print(a) # Output: 1.5
```
```python
a = mememo.mode([1, 2, 2])
print(a) # Output: 2
```

## Cruical note: The function must only take in one argument which is the list of numbers.

For example,
```python
mememo.mean(10, 15, 87)
```
will raise this error
```python
TypeError: mean() takes 1 positional argument but 3 were given
```
Any questions? Email [here](mailto:albeback01@gmail.com?subject=Python%20library%20mememo%20question.)
pioled-display-plugin 0.5.0
Use an OLED display with your Pioreactor

## PiOLED display plugin for the Pioreactor

Display growth rate, normalized OD, and temperature for each Pioreactor using the [Adafruit PiOLED display](https://www.adafruit.com/product/3527)


### Hardware required

 - [Adafruit PiOLED display](https://www.adafruit.com/product/3527)
 - [0.1" 2x20-pin Strip Right Angle Female Header](https://www.adafruit.com/product/2823)


### Software installation

Install from the UI, or run:
```
pio plugins install pioled-display-plugin
```

You may get a "hardware not installed" error. That's okay, we'll do that next.

### Hardware installation

With the Pioreactor turned off (you can pull the plug), install the 2x20 right-angle header onto the the 2x20 header on the Pioreactor HAT. Attach the PiOLED display onto the right-hand side of the new header, with the orientation as shown in the image below:

<img width="462" alt="Screenshot 2023-06-21 at 2 40 14 PM" alt="PiOLD attached to the right-angle headers." src="https://github.com/Pioreactor/PiOLED-display-plugin/assets/884032/3b3096d0-4cfa-4a74-8ff1-36cff2fb4d99">

Power back on the Pioreactor.