semvec/pypi-packages huggingface dataset:
byzpy 0.1.4
A research framework for Byzantine-robust distributed ML
License: MIT
Requires Python: >=3.9
Keywords: distributed-learning, byzantine, federated-learning, pytorch, robust-ml

# ByzPy

**ByzPy** is a unified Python framework for Byzantine-robust distributed machine learning. It provides a powerful actor runtime, declarative computation graphs, and batteries-included aggregators and attack simulators.

## Installation

Install from PyPI:

```bash
pip install byzpy              # CPU baseline
pip install "byzpy[gpu]"       # add CUDA/UCX extras
pip install "byzpy[dev]"       # add development tools (pytest, coverage)
```

## Quick Start

```python
from byzpy.aggregators.coordinate_wise.median import CoordinateWiseMedian
import torch

# Create aggregator
aggregator = CoordinateWiseMedian(chunk_size=4096)

# Aggregate gradients
gradients = [torch.randn(1000) for _ in range(10)]
result = aggregator.aggregate(gradients)
```

## Features

- **Byzantine-robust aggregators** – Krum, MDA, trimmed mean, geometric median, and more
- **Unified actor runtime** – threads, processes, GPUs, and TCP/UCX remotes share a single API
- **Declarative computation graphs** – build heterogeneous pipelines with deterministic scheduling
- **Complete examples** – parameter-server and peer-to-peer demos included

## CLI Tools

```bash
byzpy version                # installed version
byzpy doctor                 # environment diagnostics
byzpy list aggregators       # discover built-ins
```

## Documentation

📖 **Full documentation:** https://byzpy.github.io/byzpy/

**Links:**
- Homepage: https://github.com/Byzpy/byzpy
- Documentation: https://byzpy.github.io/byzpy/
- Issues: https://github.com/Byzpy/byzpy/issues
panelsplit 2.0.5
A tool for panel data analysis.
License: MIT
Requires Python: >=3.11

![PyPI - Version](https://img.shields.io/pypi/v/panelsplit)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.114933814.svg)](https://doi.org/10.5281/zenodo.14933814)

# panelsplit: a tool for panel data analysis

panelsplit is a Python package designed to facilitate time series cross-validation when working with multiple entities (aka panel data). This tool is useful for handling panel data in various stages throughout the data pipeline, including feature engineering, hyper-parameter tuning, and model estimation.

## Installation

panelsplit is tested for compatibility with python versions >= 3.11. You can install panelsplit using pip:

```bash
pip install panelsplit
```

---

## Documentation

To read the documentation, visit [here](https://4freye.github.io/panelsplit/panelsplit.html).

### Example Usage

```python
import pandas as pd
from panelsplit.cross_validation import PanelSplit

# Generate example data
num_countries = 2
years = range(2001, 2004)
num_years = len(years)

data_dict = {
    'country_id': [c for c in range(1, num_countries + 1) for _ in years],
    'year': [year for _ in range(num_countries) for year in years],
    'y': np.random.normal(0, 1, num_countries * num_years),
    'x1': np.random.normal(0, 1, num_countries * num_years),
    'x2': np.random.normal(0, 1, num_countries * num_years)
}

panel_data = pd.DataFrame(data_dict)
panel_split = PanelSplit(periods = panel_data.year, n_splits =2)

splits = panel_split.split()

for train_idx, test_idx in splits:
    print("Train:"); display(panel_data.loc[train_idx])
    print("Test:"); display(panel_data.loc[test_idx])
```

For more examples and detailed usage instructions, refer to the [examples](examples) directory in this repository. Also feel free to check out [an introductory article on panelsplit](https://towardsdatascience.com/how-to-cross-validate-your-panel-data-in-python-9ad981ddd043).

## Background

Work on panelsplit started at [EconAI](https://www.linkedin.com/company/econ-ai/) in December 2023 and has been under active development since then.

## Contributing

Contributions to panelsplit are welcome! If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request on GitHub.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
cleancore-python 0.1.2
A dependency-free audit trail system for Python data transformations.
License: MIT
Requires Python: >=3.7

# CleanCore Python

A lightweight, dependency-free audit trail system for Python data pipelines.

CleanCore automatically creates immutable, row-level audit logs for every data transformation. It helps with debugging, compliance, and understanding how your data changes across cleaning steps.

---

## Features

- Automatic row-level audit logs
- Zero external dependencies (pure Python)
- JSON-based audit output for compliance and record keeping
- Works with lists, dictionaries, and CSV-style data
- Simple decorator-based API

---

## Installation

```bash
pip install cleancore-python
Quick Start
Audit a Single Function
python
Copy code
from cleancore import audit_trail, ProvenaLogger, generate_terminal_report

@audit_trail(rule_id="GDPR_EMAIL_MASKING")
def clean_emails(data):
    result = []
    for row in data:
        new_row = row.copy()
        if '@' in new_row.get('email', ''):
            new_row['email'] = '***@***.***'
        result.append(new_row)
    return result

logger = ProvenaLogger("Single_Transformation")

data = [
    {'id': 1, 'email': 'test@example.com'},
    {'id': 2, 'email': 'user'}
]

cleaned = clean_emails(data, provena_logger=logger)

print(generate_terminal_report(logger))
Pipeline Usage
python
Copy code
from cleancore import audit_pipeline, audit_trail
import csv

def load_data(path):
    with open(path) as f:
        return list(csv.DictReader(f))

@audit_trail(rule_id="STANDARDIZE_NAMES")
def standardize_names(data):
    return data

@audit_trail(rule_id="FILL_MISSING_VALUES")
def fill_missing(data):
    return data

with audit_pipeline("Customer_Onboarding_Pipeline") as logger:
    data = load_data("customers.csv")
    data = standardize_names(data, provena_logger=logger)
    data = fill_missing(data, provena_logger=logger)

logger.export_json("customer_pipeline_audit.json")
Output
CleanCore generates a human-readable terminal report and a machine-readable JSON audit log containing:

Transformation name

Rule ID

Rows before and after

Number of changed rows

Sample value changes

Execution timestamps

API Overview
audit_trail – Decorator for auditing functions

ProvenaLogger – Collects audit events

audit_pipeline – Context manager for multi-step pipelines

generate_terminal_report() – Prints terminal summary

export_json() – Saves audit log to file

Source Code
GitHub Repository
https://github.com/Sidra-009/cleancore-python-library

Issues, feature requests, and pull requests are welcome.

License
MIT License. See the LICENSE file for details.