semvec/pypi-packages huggingface dataset:
modsim 0.5.2
A Simple Modbus TCP Device Simulator used for modpoll tool
Requires Python: <4.0,>=3.8.2

# ModSim - A Simple Modbus TCP Device Simulator

*modsim* is a simple Modbus TCP device simulator deployed at `modsim.topmaker.net:502`.
It works as a remote Modbus-TCP (virtual) device, which has already been populated with all 4 types of registers, i.e.
- Coil Type
- Discrete input Type
- Input register Type
- Holding register Type

It is recommended to use [modpoll](https://github.com/gavinying/modpoll) tool to communicate with it, the example configuration is as following,

```
device,modsim01,1,,
poll,coil,0,16,BE_BE
ref,coil01-08,0,bool8,rw
ref,coil09-16,1,bool8,rw
poll,discrete_input,10000,16,BE_BE
ref,di01-08,10000,bool8,rw
ref,di09-16,10001,bool8,rw
poll,input_register,30000,20,BE_BE
ref,input_reg01,30000,uint16,rw
ref,input_reg02,30001,uint16,rw
ref,input_reg03,30002,uint16,rw
ref,input_reg04,30003,uint16,rw
ref,input_reg05,30004,int16,rw
ref,input_reg06,30005,int16,rw
ref,input_reg07,30006,int16,rw
ref,input_reg08,30007,int16,rw
ref,input_reg09,30008,uint32,rw
ref,input_reg10,30010,uint32,rw
ref,input_reg11,30012,int32,rw
ref,input_reg12,30014,int32,rw
ref,input_reg13,30016,float32,rw
ref,input_reg14,30018,float32,rw
poll,holding_register,40000,44,BE_BE
ref,holding_reg01,40000,uint16,rw
ref,holding_reg02,40001,uint16,rw
ref,holding_reg03,40002,uint16,rw
ref,holding_reg04,40003,uint16,rw
ref,holding_reg05,40004,int16,rw
ref,holding_reg06,40005,int16,rw
ref,holding_reg07,40006,int16,rw
ref,holding_reg08,40007,int16,rw
ref,holding_reg09,40008,uint32,rw
ref,holding_reg10,40010,uint32,rw
ref,holding_reg11,40012,int32,rw
ref,holding_reg12,40014,int32,rw
ref,holding_reg13,40016,float32,rw
ref,holding_reg14,40018,float32,rw
ref,holding_reg15,40020,uint64,rw
ref,holding_reg16,40024,int64,rw
ref,holding_reg17,40028,float64,rw
ref,holding_reg18,40032,float64,rw
ref,holding_reg19,40036,string16,rw
```

## Quick Start

A docker image has been provided for user to directly run the program,

```bash
docker run -p 5020:5020 topmaker/modsim:latest
```

The above one-line command will create a virtual Modbus TCP device running at `localhost:5020`.

To verify it, you can test by [modpoll](https://github.com/gavinying/modpoll) tool with the following command,

```bash
modpoll \
  --tcp localhost \
  --tcp-port 5020 \
  --config https://raw.githubusercontent.com/gavinying/modpoll/master/examples/modsim.csv
```

> **_Note_**: add `sudo` before `docker run` command if you want to use the Modbus TCP standard port `502`.
ComfyUI_Ib_CustomNodes 0.2.3
Load Image From Path, PIL.Image
Keywords: comfyui

# ComfyUI_Ib_CustomNodes
## Load Image From Path
```python
def LoadImageFromPath(
    image: str = r'ComfyUI_00001_-assets\ComfyUI_00001_.png [output]'
) -> tuple[Image, Mask]
```

ComfyUI's built-in `Load Image` node can only load uploaded images, which produces duplicated files in the input directory and cannot reload the image when the source file is changed. `Load Image From Path` instead loads the image from the source path and does not have such problems.

One use of this node is to work with Photoshop's [Quick Export](https://helpx.adobe.com/photoshop/using/export-artboards-layers.html#:~:text=in%20Photoshop.-,Quick%20Export%20As,-Use%20the%20Quick) to quickly perform img2img/inpaint on the edited image. Update: For working with Photoshop, [comfyui-photoshop](https://github.com/NimaNzrii/comfyui-photoshop) is more convenient and supports waiting for changes. See [tutorial at r/comfyui](https://www.reddit.com/r/comfyui/comments/18jygtn/new_ai_news_photoshop_to_comfyui_v1_is_finally/).

The image path can be in the following format:
- Absolute path:

  `D:\ComfyUI\output\ComfyUI_00001_-assets\ComfyUI_00001_.png`

- Relative to the input directory:

  `ComfyUI_00001_-assets\ComfyUI_00001_.png [input]`

- Relative to the output directory:

  `ComfyUI_00001_-assets\ComfyUI_00001_.png [output]`

- Relative to the temp directory:

  `ComfyUI_00001_-assets\ComfyUI_00001_.png [temp]`

## Installation
Install via the Custom Nodes Manager in [ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager).

## Usage Example
![usage](./usage.jpg)

## PIL.Image
```python
def PILToImage(
    images: PilImage
) -> Image
```
```python
def PILToMask(
    images: PilImage
) -> Image
```
```python
def ImageToPIL(
    images: Image
) -> PilImage
```
datastructclass 0.1.1
datastructclass.
Requires Python: >=3.9
Keywords: dataclass, serialization, struct

# datastructclass

A `DataStructClass` is a `dataclass` with struct-like semantics. It can be
serialized/deserialized to/from `bytes`.

A subclass of `DataStructClass` is a `dataclass`, with the following additional
features:

```python
<class>.format
<class>.size
<class>.unpack
<instance>.pack
<instance.__bytes__>
```

Each member of a `DataStructClass` must provide struct metadata via `typing.Annotated`.

## Example

```python
from struct import Struct
from typing import Annotated
from datastructclass import DataStructClass

class MyDSC(DataStructClass):
    # Unsigned long:
    member_a: Annotated[int, Struct("=L")]
    # Double:
    member_b: Annotated[float, Struct("=d")]
    # Array of signed long with length 4.
    member_c: Annotated[list[int], Struct("=4I")]
    # Array of char, aka. a string, with length 8:
    member_d: Annotated[bytes, Struct("=8s")]


data = MyDSC(4000, 3.14, [-2, -1, 0, 1], b"charlie  ")
# 'send_over_wire' could a network socket, a serial port, etc.
send_over_wire(data.pack())
```

## Limitations

`DataStructClass` cannot contain variable-length members.
secret-updater 0.1.2
CLI tool to update GitHub repository secrets.
Requires Python: >=3.6

# GitHub Secret Updater

## Background
Managing secrets in GitHub repositories is crucial for maintaining security in CI/CD pipelines. This script automates the process of updating secrets in GitHub repositories using GitHub API.

## What is the Script/Package
This script allows you to update GitHub secrets either by specifying individual secret names and values or by reading from an environment file (`.env`). It fetches the public key for the repository, encrypts the secret using the public key, and then updates the secret in the repository.

## Usage

### Installation
1. Install the required Python packages:
    ```sh
    pip install secret-updater
    ```

2. Save the script to a file, for example, `update_github_secrets.py`.

### Command Line Arguments
- `--secret`: Name of the secret to update
- `--value`: Value of the secret to update
- `--repo`: Name of the repository (in the format `owner/repo`)
- `--token`: GitHub token (can also be set as an environment variable `GH_TOKEN`)
- `--env-file`: Path to the environment file containing secrets (recommended filename: `.env`)

### Examples

#### Update a Single Secret
To update a single secret:
```sh
secret-updater --secret SECRET_NAME --value SECRET_VALUE --repo owner/repo --token YOUR_GITHUB_TOKEN
```

To update a set of secrets from an environment file:
```sh
secret-updater --env-file .env --repo owner/repo --token YOUR_GITHUB_TOKEN
```

The env file should contain the secrets in the formats

`SECRET_NAME=SECRET_VALUE`

or 

`export SECRET_NAME="SECRET_VALUE"`
QuaNFS 0.0.1
A python package for implementing feature selection using quantum-based nature inspired algorithms

# QuantumBasedGeneticAlgorithm
Implements Quantum Based Genetic Algorithm for Feature Selection

How to use:

Step 1: Preprocess the dataset (Encoding, Imputing, Removing null values etc...)

Step 2: Split the dataset into X, y where both X and y are PandasDataFrame

Step 3: run the QGA_Algorithm 

Step 4: initialize the algorithm

              qga = QGA(X, y, n_of_pop, n_of_gen) # where X and y are dependent and independent variables. And n_of_pop and n_of_gen is numnber of population and number of generations
              
Step 5: Run generation 0

              Q = qga.run_gen_0()
              
Step 6: Run QGA

              best_individuals = qga.run_qga(Q[0]) # Q[0] because Q is a numpy array in a tuple... we only need numpy array
              
Step 7: Build a new dataset with reduced features

              qga.build_new_dataset(best_individuals)
PyMVPA 4.0.0
Multivariate Pattern Analysis in Python
Requires Python: >=3.7

PyMVPA is a Python module for multivariate pattern analysis (MVPA) of fMRI datasets with a high-level interface that is easy to learn and use, building on numpy, scipy, matplotlib, nibabel, h5py, scikit-learn, joblib, and, optionally, other packages for neuroimaging, machine learning, and psychophysics.PyMVPA (Python MultiVariate Pattern Analysis) is used for multivariate pattern analysis of neuroimaging data.It supports data preparation, loading, and visualization,making it suitable for machine learning applications in neuroscience
al-random-art-al 0.0.1
Инструменты для генерации случайных художественных элементов.
Requires Python: >=3.6

# Random Art Generator

`random-art` — библиотека для генерации случайного цифрового искусства.

## Возможности

- Создание слоёв с элементами (шум, круги и др.).
- Сохранение/загрузка изображений.
- Обработка изображений с помощью тензоров.

## Установка

```bash
pip install -r requirements.txt