semvec/pypi-packages huggingface dataset:
precice-cli 1.0.0
A unified command line interface for preCICE tools.
Requires Python: >=3.8
Keywords: preCICE, XML, configuration, format, visualization

# preCICE CLI

The `precice-cli` is a uniform and simple access to all command line tools of preCICE.
Some commands use tools provided by the preCICE library and require it to be installed.
The installed executables must be in PATH.

## Installation options

Install directly from PyPi using [pipx](https://pipx.pypa.io/stable/) or via pip:

```console
pipx install precice-cli
```

## Usage examples


### Configuration

```console
precice-cli config format precice-config.xml
```

```console
precice-cli config visualize precice-config.xml -o graph.pdf
```

```console
precice-cli config check precice-config.xml
precice-cli config check precice-config.xml SolverOne
```

### Profiling

Pre-processing:

```console
precice-cli profiling merge
```

Post-processing:

```console
precice-cli profiling export
precice-cli profiling trace
precice-cli profiling analyze SolverOne
```

### Version display

```console
precice-cli version
```

### Case generation

```console
precice-cli init
```
mfgwhitebox 0.0.9
A package to convert between Excel and XML files.
Requires Python: >=3.6

# Excel-XML Converter

A simple command-line tool to convert between Excel (.xlsx) and XML files based on a specific data structure.

## Installation

```bash
pip install mfgwhitebox
```

## Usage

### Excel <=> XML，Excel <=> JSON，不支持XML与JSON互转
### 若outputFile不写时，默认转换到文件名的json文件

```bash
mfgwhitebox <inputFile> [outputFile]
```
pypamguard 1.0.1
A package for processing PAMGuard binary file outputs in Python.
Requires Python: >3.9

![PyPI - Version](https://img.shields.io/pypi/v/pypamguard?label=pypi)
![PyPI - Status](https://img.shields.io/pypi/status/pypamguard)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pypamguard)
![GitHub contributors](https://img.shields.io/github/contributors/PAMGuard/pypamguard)
![GitHub License](https://img.shields.io/github/license/PAMGuard/pypamguard)
![GitHub last commit](https://img.shields.io/github/last-commit/PAMGuard/pypamguard)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/PAMGuard/pypamguard/tests.yml?label=tests)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/PAMGuard/pypamguard/documentation.yml?label=docs)
![GitHub Tag](https://img.shields.io/github/v/tag/PAMGuard/pypamguard?label="github-version")
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.16789563.svg)](https://doi.org/10.5281/zenodo.16789563)
![PyPI - Downloads](https://img.shields.io/pypi/dm/pypamguard)

pypamguard is a package for processing PAMGuard binary file outputs in Python.

* **PyPI**: https://pypi.org/project/pypamguard/
* **GitHub**: https://github.com/PAMGuard/pypamguard
* **Documentation**: https://www.pamguard.org/pypamguard/
* **Website**: https://www.pamguard.org/
* **Zenodo**: https://doi.org/10.5281/zenodo.16789563

## Installation

```bash
pip install pypamguard
```

## Getting Started

Example of loading in a simple PAMGuard data file into Python.

```python
import pypamguard
df = pypamguard.load_pamguard_binary_file('path/to/data/file.pgdf')
```

Then, for example, you can print out the file header like so.

```python
print(df.file_info.file_header) # File header
print(df.file_info.file_header.version) # File version
```

Modules also have a `file_info.module_header`, `file_info.module_footer`, `file_info.file_footer`, and most importantly `data` and `background`. 

```python
print("File length", len(df.data)) # Number of module data chunks
first_obj = df.data[0] # First module data chunk
for chunk in df.data: # Looping through the data
    print(chunk.identifier)
```

For more information, see the [documentation](https://www.pamguard.org/pypamguard/).

## Bugs/Requests

Please use the [Github issue tracker](https://github.com/PAMGuard/pypamguard/issues) to submit bugs or feature requests.

## License

This software is distributed under the terms of the MIT license. pypamguard is free and open source. 

If you use this code, please cite it as listed on Zenodo: https://doi.org/10.5281/zenodo.16789563
e.g. James Sullivan. (2025). PAMGuard/pypamguard: Version 1.0.0 (v1.0.0). Zenodo. https://doi.org/10.5281/zenodo.16789564

## Contributing

Check [CONTRIBUTING.md](CONTRIBUTING.md) to get started.
coralearn 0.2.1
An AI library written using only NumPy
Requires Python: >=3.8

# Coralearn
An AI library written using only **NumPy**.

![PyPI](https://img.shields.io/pypi/v/coralearn)
![Python](https://img.shields.io/pypi/pyversions/coralearn)
![Downloads](https://img.shields.io/pypi/dm/coralearn)
![License](https://img.shields.io/github/license/Coralap/CoraLearn)

---

## Installation⬇️
```bash
pip install coralearn
```

## Quick Example

Here’s a simple neural network example using **CoraLearn**:

```python
import numpy as np
import pandas as pd

from coralearn.neural_network import Dense, Sequential
from coralearn.optimizers import SGDMomentum
from coralearn.activations import relu, linear_activation
from coralearn.losses import mean_squared_error
from coralearn.scalers import MinMaxScaler

# Alternatively, you can import everything directly from coralearn
# from coralearn import Dense, Sequential, relu, linear_activation, mean_squared_error, SGDMomentum, MinMaxScaler

# Load training data
train_data = pd.read_csv("Train.csv")

X = train_data[["col1", "col2", "col3"]].values   # your chosen input columns
y = train_data["target"].values                   # target column

# Scale the input features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Build a sequential model
model = Sequential([
    Dense(input_size=32, output_size=16, activation=relu),
    Dense(input_size=16, output_size=8, activation=relu),
    Dense(input_size=8, output_size=1, activation=linear_activation),
])

# Compile with loss function and an optimizer
model.compile(loss=mean_squared_error, optimizer=SGDMomentum(lr=0.05))

# Train the model
model.train(X_scaled, y, epochs=20, batch_size=32)

# Make a prediction on new data
X_new = np.random.rand(5, 32)   # example new inputs
X_new_scaled = scaler.transform(X_new)

y_pred = model.forward(X_new_scaled)
print("Predictions:", y_pred)
```

## Current Features

### Scalers 🔢 
- MinMaxScaler
- RobustScaler
- StandardScaler

### Losses 📉
- binary_cross_entropy
- mean_squared_error
- sparse_categorical_cross_entropy

### Optimizers⚡ 
- SGD
- SGDMomentum
- NAG
- AdaGrad
- RMSprop
- Adam

### Activations ⏰
- relu
- linear_activation
- softmax
- sigmoid

### Neural Network Components 🏗️ 
- Dense (fully connected layer)
- Sequential (model container)
- CNN coming soon