semvec/pypi-packages huggingface dataset:
foundry-instance-manager 0.1.32
A command-line tool for managing Foundry VTT instances
Requires Python: <4.0,>=3.9

# Foundry Instance Manager

## THIS PROJECT IS IN PROGRESS AND NOT READY FOR USE

A CLI tool for managing multiple Docker containers that share the same image but have individual data directories and a shared data directory.

## Features

- Create and manage multiple Docker containers from the same image
- Each container has its own isolated data directory
- Shared data directory accessible by all containers
- Easy-to-use CLI interface
- Container status monitoring
- **Automated changelog generation**
- **Automated version bumping and release workflow**
- **Security checks (Bandit, Safety)**

## Installation

1. Clone this repository
2. Install [Poetry](https://python-poetry.org/docs/#installation)
3. Install dependencies:
```bash
poetry install
```

## Usage

```bash
# Create a new container
poetry run fim create --name my-container --image my-image

# List all containers
poetry run fim list

# Start a container
poetry run fim start --name my-container

# Stop a container
poetry run fim stop --name my-container

# Remove a container
poetry run fim remove --name my-container
```

## Configuration

The tool uses the following directory structure:
- `./data/shared/` - Shared data directory accessible by all containers
- `./data/containers/<container-name>/` - Individual container data directories

## Requirements

- Python 3.9+
- Docker installed and running
- Poetry

## CI/CD Pipeline (GitHub Actions)

This project uses a robust CI/CD pipeline with the following stages:

- **Quality Checks**: Linting (flake8, black, isort), type checking (mypy), and unit tests with coverage (pytest, pytest-cov). Coverage is uploaded to Codecov.
- **Security**: Bandit for static security analysis and Safety for dependency vulnerability checks.
- **Version Management**: Automated version bumping and changelog generation on every push to `main`.
- **Release**: Builds the package, creates a GitHub release, and publishes to PyPI when a new tag is created.

### How it works
- On every push or pull request to `main`, the pipeline runs quality and security checks.
- On pushes to `main`, if all checks pass, the version is bumped, a changelog is generated, and a new tag is created.
- When a tag is pushed, a release is created and the package is published to PyPI.

## Changelog Generation

Changelog is automatically generated using the `changelog` tool. To manually generate or update the changelog:
```bash
poetry run changelog generate-md CHANGELOG.md
```

## Security

- Run Bandit:
  ```bash
  poetry run bandit -r foundry_instance_manager
  ```
- Run Safety:
  ```bash
  poetry run safety check
  ```
palworld-server-launcher 0.1.19
A simple tool to install and manage a Palworld dedicated server on Linux.
Requires Python: >=3.8

# Palworld Server Launcher

A simple command-line tool to help you install, manage, and run a dedicated Palworld server on Linux. This tool automates the setup process, including installing dependencies, configuring the server as a systemd service, and setting up permissions for easy management.

## Features

- **Automated Installation**: Installs SteamCMD and the Palworld dedicated server with a single command.
- **Package Manager Repair**: Automatically attempts to fix common `apt` and `dpkg` issues before installation.
- **Service Management**: Creates a `systemd` service to run the server in the background and start it on boot.
- **Permission Handling**: Configures Polkit rules to allow server management (start, stop, restart) without needing `sudo`.
- **Unattended Setup**: Automatically accepts the SteamCMD license agreement for a smoother setup process.

## Prerequisites

- An Ubuntu Linux distribution.
- `sudo` privileges for the user running the script.

## Installation

```bash
pip install palworld-server-launcher
```

## Usage

After installation, you can use the `palworld-server-launcher` command:

### Install the Server

This command will install the server, configure it with the specified port and player count, and set it up as a systemd service.

```bash
# Install the server with default settings (port 8211, 32 players)
palworld-server-launcher install

# Install with custom settings and start the server immediately
palworld-server-launcher install --port 8211 --players 16 --start
```

### Manage the Server

Once installed, you can control the server state. Thanks to the Polkit setup, you do not need `sudo` for these commands.

```bash
# Start the server
palworld-server-launcher start

# Stop the server
palworld-server-launcher stop

# Restart the server
palworld-server-launcher restart

# Check the server's status
palworld-server-launcher status

# Enable the server to start automatically on boot
palworld-server-launcher enable

# Disable the server from starting on boot
palworld-server-launcher disable

### Update the Server
palworld-server-launcher update
```
StepByStepLinearRegression 0.1.1
A package for step-by-step regression analysis including simple, multiple, and logistic regression.
Requires Python: >=3.7

# Step-by-Step Linear Regression

This Python package is designed to assist students learning **simple**, **multiple**, and **logistic regression** by breaking down every calculation step.  
It is especially helpful when solving exam-style problems, where it's easy to make minor arithmetic errors that derail understanding.  
Instead of spending excessive time on mechanical computation, you can use this tool to verify intermediate steps, identify mistakes quickly, and focus more on understanding the underlying formulas and concepts.

## Features
- `.fit(X, y)` — fits the model
- `.summary()` — prints slope, intercept, SSR, SSE, MSE, etc.
- `.steps_df` — prints an annotated `DataFrame` showing internal computation steps

## Installation

You can install the package from PyPI:

```bash
pip install StepByStepLinearRegression
```

## Usage
It is recommended to run this package in .ipynb (Jupyter Notebook) format for best interactivity and readability of computation steps.
Check [`test.ipynb`](https://github.com/mellamochiao/StepByStepLinearRegression/blob/main/test.ipynb) to see how to use this package in practice.

## Author
Created by [Mellamochiao](https://github.com/mellamochiao).
devicer.py 0.2.0
Open-Source Python Middleware for Digital Fingerprinting
Requires Python: >=3.8
Keywords: fingerprinting, identification, middleware, tracking

# FP-Devicer
## Developed by Gateway Corporate Solutions LLC

FP-Devicer is a digital fingerprinting middleware library designed for ease of use and near-universal compatibility with servers.

Importing and using the library to compare fingerprints between users is as simple as collecting some user data and running the calculateConfidence function.
```python
from devicer.confidence import calculate_confidence

user1, user2 = {
  """Collected data goes here"""
}

const confidence = calculate_confidence(user1, user2)
```

The resulting confidence will range between 0 and 100, with 100 providing the highest confidence of the users being identical.
rbobjecttracking 3.2.0
A python library for single-object tracking.
Requires Python: >=3.6

rbobjecttracking is based on an algorithm I invented called RBOT. it stands for ROI Based Object Tracking.

using rbobjecttracking, you can get around 50-70 FPS on a CPU
To use rbobjecttracking, first create your custom dataset using ```rbot.dataCollector```.

``` python
from rbot.dataCollector import DataCollector # Import the DataCollector class

data_collector = DataCollector() # Create the DataCollector object
data_collector.collectData() # This will open a GUI window using customtkinter and opencv.
```
After filling in the text fields and collecting the image samples, train a small model using ```rbot.trainer```.

``` python
from rbot.trainer import Trainer # Import the Trainer class

trainer = Trainer(dataset_path="<dataset name that you created>", img_size=(128, 128), model_path="<path you want to save your model>") # Create the Trainer object
                  
trainer.train() # This will train and save the model to your specified model path
```

Training should usually take around 10seconds to a minute on your GPU depending on your dataset size, and image size.

After training, you can need to get the color mask of the object with ```rbot.colorExtractor```.

``` python
from rbot.colorExtractor import ColorRangeSelector # import the ColorRangeSelector class

rangeSelector = ColorRangeSelector() # Create the class object
rangeSelector.select_color_range() # call the function to select your object's color range
```

This will open a GUI with the masked webcam, and some sliders. You need to adjust the sliders so that everything but your object turns black in the webcam view.

After selecting your object's color range, you can then start the object detection with ```rbot.rbot```
``` python
from rbot.rbot import RBOT # Import the RBOT class
import cv2 # Import opencv for accessing the webcam

rbot = RBOT(hsvValues="<Your object's color range>", image_size=(128, 128), minimum_confidence=0.9) # Create the RBOT object
cap = cv2.VideoCapture(0) # Access the webcam

while True:
    ret, frame = cap.read() # Get a frame from the webcam

    processed_frame = rbot.track_object(frame=frame, color=(0, 255, 0), width=2) # Process the frame

    cv2.imshow("processed frame", processed_frame) # Display the proccesed frame
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
```