semvec/pypi-packages huggingface dataset:
DTS-CDD__Wdis 1.4.2
Static Features Extraction Engine
Requires Python: <4.0,>=3.10

# MPH Static Features Extraction

This project allows the user to extract MalwPackHeat-like static features from Windows PE files, following the phases described in *When Static Analysis Fail*. 

## Prerequisites

- *Setup* the PE malware directory such that they have the following structure:

    ```plaintext
        <YOUR_PE_MALWARE_DIR>/
        ├── <FAMILY_0>/
        │   ├── SHA_0_0
        │   ├── SHA_0_1
        │   ├── ...
        │   └──
        ├── <FAMILY_1>/
        │   ├── SHA_1_0
        │   ├── ...
        │   └──
        ├── ...
        └── 
    ```
    where `FAMILY_0,  FAMILY_1, ...` are the directories named with the malware family and `SHA_0_0,  SHA_0_1, ...` are the PE files named with their SHA256.

- *Run* pre-feature selection train/test split, for example by using `train-test-splits` repository
- *Make sure* to have a running and active version of [Docker](https://docs.docker.com/engine/install/).

## Usage

- *Configure* the Docker Compose file by providing the following information:
  - `MALWARE_DIR_PATH`: directory of YOUR_PE_MALWARE_DIR
  - `SPLITTED_DATASET_PATH`: pre-feature selection train/test split directory
  - `FINAL_DATASET_DIR`: directory where to store the vectorized dataset given as output
  - `N_PROCESSES`: number of processors to use
- *Start* the extraction process:
  ```bash
  docker compose up -d
  ```

## Resource Considerations

Feature extraction on large PE datasets is highly memory-intensive.  
While requirements depend on dataset size, users should be aware that the process can consume substantial system resources.

As a concrete example, processing a PE dataset (`MALWARE_DIR_PATH`) of approximately 177 GB required a machine equipped with 512 GB of RAM to complete extraction reliably.  
For smaller datasets, proportionally less memory will be needed, but large-scale processing should be expected to require several hundred gigabytes of RAM.

Plan hardware capacity accordingly before launching the extraction process.


## Authors

- Luca Fabri
sanssouci 0.1.5
Post hoc inference via multiple testing
Requires Python: >=3.10

# sanssouci.python

### General presentation

Post hoc inference via multiple testing

This projet implements post hoc inference-based methods based for neuroimaging and genomics. See also the [R package sanssouci](https://sanssouci-org.github.io/sanssouci/) for an implementation in R.

### Permutation-based confidence envelopes

A typical output for fMRI data (Localizer data set, left vs right click) is shown below:

![Confidence envelopes](img/confidence-envelopes.png)

The left plot displays an upper confidence envelope on the False Discovery Proportion among the most significant voxels. The right plot displays a lower confidence envelope on the number of True Postives among the most significant voxels. See the [Script to reproduce this plot](./examples/posthoc_fMRI.py).

### Test the package on synthetic data

Here is a simple code you can use to test and get familiar with the *sanssouci* package. Other examples are given in the *examples* directory.

```
import sanssouci as sa
import numpy as np



#1) generate phantom data
p = 130
n = 45


X=np.random.randn(n,p)  #NOTE: no signal!! we expect trivial bounds
categ=np.random.binomial(1, 0.4, size=n)


#2) test the algorithm
B = 100
pval0=sa.get_permuted_p_values(X, categ, B=B , row_test_fun=sa.row_welch_tests)

piv_stat=sa.get_pivotal_stats(pval0)


#3) Compute Bounds

alpha=0.1

lambda_quant=np.quantile(piv_stat, alpha)
thr=sa.linear_template(lambda_quant, p, p)
swt=sa.row_welch_tests(X, categ)
p_values=swt['p_value'][:]
pvals=p_values[:10]

bound = sa.max_fp(pvals, thr)
print(bound)

```
bandersnatch-vrfs 0.6.1
Python Bandersnatch VRFs library utilizing the RUST ark-ec-vrfs cryptographic library
Requires Python: >=3.9

# py-bandersnatch-vrfs
Python Bandersnatch VRFs library utilizing the RUST [ark-ec-vrfs](https://github.com/davxy/ark-ecvrf) cryptographic library

## Installation

### Compile for local development

```
pip install -r requirements.txt
maturin develop
```
### Build wheels
```
pip install -r requirements.txt

# Build local OS wheel
maturin build --release

# Build manylinux1 wheel
docker run --rm -v $(pwd):/io ghcr.io/pyo3/maturin build --release

```