semvec/pypi-packages huggingface dataset:
ts-programs-gg 1.0.0
A collection of 7 time series analysis programs
License: MIT
Requires Python: >=3.7

# Time Series Programs Library

A Python library containing 7 time series analysis programs for forecasting and analysis using the AirPassengers dataset.

## Installation

You can install this package using pip:

```bash
pip install .
```

Or for development mode:

```bash
pip install -e .
```

## Requirements

- Python >= 3.7
- pandas >= 1.3.0
- numpy >= 1.21.0
- matplotlib >= 3.4.0
- statsmodels >= 0.13.0
- scikit-learn >= 0.24.0

## Usage

After installation, you can import and run any of the 7 programs:

```python
from ts_programs import p1, p2, p3, p4, p5, p6, p7

# Run program 1: Exponential Smoothing Methods
p1()

# Run program 2: Stationarity Testing
p2()

# Run program 3: Moving Averages & ACF/PACF
p3()

# Run program 4: AutoRegressive Models
p4()

# Run program 5: Moving Average Models
p5()

# Run program 6: ARMA Model
p6()

# Run program 7: ARIMA Model
p7()
```

## Programs Overview

### p1() - Exponential Smoothing Methods
Compares Simple Moving Average (SMA), Simple Exponential Smoothing (SES), and Holt-Winters forecasting methods. Displays metrics (MAE, MSE, RMSE) and visualization plots.

### p2() - Stationarity Testing
Tests for stationarity using Augmented Dickey-Fuller (ADF) and KPSS tests. Compares the original series with white noise.

### p3() - Moving Averages & ACF/PACF Plots
Visualizes moving averages (6-month and 12-month) and autocorrelation functions (ACF and PACF).

### p4() - AutoRegressive (AR) Models
Fits AR models of various orders (1, 2, 3, 5, 10) and evaluates their performance using MAE, MSE, and RMSE.

### p5() - Moving Average (MA) Models
Fits MA models of various orders (1, 2, 3, 5) and evaluates their performance.

### p6() - ARMA Model
Fits an ARMA(2,1) model and generates forecasts for the test period.

### p7() - ARIMA Model
Fits an ARIMA(2,1,2) model and generates future forecasts.

## Data Requirements

All programs expect an `AirPassengers.csv` file in your current working directory with the following structure:
- Column 1: `Month` (date column)
- Column 2: `#Passengers` (numerical values)

You can download the AirPassengers dataset from various sources or use your own time series data with the same format.

## License

MIT License
py2binmod 0.1.1
CLI tool to compile Python packages into Binmod modules
License: MIT
Requires Python: <4.0,>=3.10

# py2binmod

Compile Python projects to Binmod WebAssembly modules.

## Overview

py2binmod transpiles Python code that uses the Binmod Python MDK into Rust, bundles a Python interpreter (RustPython), and compiles everything to WebAssembly. This allows you to write plugins in Python and run them in any Binmod runtime.

**Trade-offs:** Larger module sizes and slower startup times compared to native Rust modules, but enables using Python code in the Binmod ecosystem.

## Installation

### Option 1: Docker (Recommended)

No local dependencies required:

```bash
docker run -ti -v "$(pwd)":/app ghcr.io/binmod-io/py2binmod:0.1.0 build
```

### Option 2: Install via pip

Requires Rust toolchain:

```bash
pip install py2binmod
```

**Prerequisites for pip installation:**
- Install Rust from [rustup.rs](https://rustup.rs/)
- Add the WebAssembly WASI Preview 1 target:
  ```bash
  rustup target add wasm32-wasip1
  ```

## Usage

### Build Command

Compile your Python module to WebAssembly:

**With Docker:**
```bash
docker run -ti -v "$(pwd)":/app ghcr.io/binmod-io/py2binmod:0.1.0 build [--release]
```

**With pip:**
```bash
py2binmod build [--release]
```

Your compiled WebAssembly module will be at:
```
artifacts/wasm32-wasip1/[debug|release]/<project_name>.wasm
```

### Custom Output Directory

```bash
py2binmod build --out-dir ./custom_output
```

### Transpile Command

Generate Rust code without compiling:

```bash
py2binmod transpile [--out-dir ./rust_output]
```

Without `--out-dir`, prints to stdout. Useful for debugging.

## How It Works

py2binmod:
1. Parses your Python project that uses the Binmod Python MDK
2. Generates a Rust wrapper using the Binmod Rust MDK
3. Bundles RustPython (a Python interpreter written in Rust)
4. Compiles everything to WebAssembly with the `wasm32-wasip1` target

Your Python code runs in the bundled interpreter, wrapped in a Rust layer that handles the Binmod protocol.

## License

MIT License

## Support

If you encounter issues or have questions, please open an issue on GitHub.