semvec/pypi-packages huggingface dataset:
tensor-chess 0.1.2
High-performance chess move generation with tensor export.
License: MIT
Requires Python: >=3.9


# tensor_chess

Optimized chess position engine with Python bindings and tensor export designed for fast reinforcement-learning and analytics workflows.

## Features
- High-performance C move generator exposed as `tensor_chess.Position`.
- Push/pop stack for reversible play, legal move generation, state inspection, and FEN export.
- Direct tensor export to 15×8×8 uint8 planes ready for ML pipelines.
- Dead-draw detection, result reporting, and bitboard access for advanced heuristics.

## Installation
```bash
pip install tensor-chess
```

## Quick Start
```python
from tensor_chess import Position

pos = Position()
pos.push("e2e4")
pos.push("e7e5")
tensor = pos.to_tensor()

print(pos.board())
print(len(tensor))  # 960 bytes
```

## Documentation
See `docs/API_REFERENCE.md` for the full API.
ai-git-guardian 0.1.0
An AI-powered Git pre-commit hook using Ollama to review code.
License: MIT
Requires Python: >=3.8
Keywords: git, hook, ai, llm, codereview, ollama

# 🤖 Git Guardian AI

An intelligent Git pre-commit hook that uses a local Ollama LLM to automatically review your code changes before you commit them.

## Features

-   **Automated Code Review**: Catches potential bugs, security flaws, and performance issues.
-   **Local & Private**: Uses your own Ollama instance, so your code never leaves your machine.
-   **Configurable**: Easily configure the model, blocking rules, and ignored files.
-   **Easy Installation**: Get started in any Git repository with two commands.

## Installation

You need to have a running Ollama instance with a model pulled (e.g., `ollama pull codellama:latest`).

Install the package using pip:

```bash
pip install git-guardian-ai
````

## Usage
Navigate to your Git repository:

```bash
cd /path/to/your/project
````
**Run the install command**: This sets up the pre-commit hook in your repository's .git folder.

````bash
guardian install
````

**(Optional) Configure Guardian**: Create a .guardian.toml file in the root of your repository to customize the settings.

````bash
# .guardian.toml
model = "llama3:8b"
block_on = ["security", "logic"]
warn_on = ["performance", "style"]
````
Now, whenever you run git commit, the Guardian will automatically analyze your staged changes!
aerotrace-parsers 0.4.0
Aircraft Engine Monitoring System (EMS) data parsers for real-time telemetry processing
License: MIT
Requires Python: >=3.9
Keywords: aircraft, aviation, cgr30p, ems, engine, telemetry

# AeroTrace Parsers

[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
[![PyPI version](https://img.shields.io/pypi/v/aerotrace-parsers.svg)](https://pypi.org/project/aerotrace-parsers/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A Python package for parsing aircraft Engine Monitoring System (EMS) telemetry data into a unified format for real-time monitoring and analysis.

## Supported EMS Types
| EMS Type | Status | Description |
|----------|--------|-------------|
| E.I CGR-30P  | 🚧 In Progress | Electronics International CGR-30P Primary |

## Installation
```bash
pip install aerotrace-parsers
```

## Quick Start
```python
from aerotrace.parsers import cgr30p

# Parse real CGR-30P flight data from an example file
for engine_data in cgr30p.parse_file('docs/example-cgr30p-flight-data.csv'):
    print(f"RPM: {engine_data.rpm.left}/{engine_data.rpm.right}")
    print(f"Fuel: {engine_data.fuel.quantity}L")
    # ... process engine data
```

For complete data model definitions, see [`src/aerotrace/models/engine.py`](src/aerotrace/models/engine.py).

## Development
### Setup
```bash
git clone https://github.com/alexc/aerotrace-parsers.git
cd aerotrace-parsers
make install
```

### Running Tests
```bash
make test
```

### Code Quality
```bash
make lint
make format
```

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
hyso 0.1.6
Hysop: Custom CNN models, SE/CBAM blocks, callbacks, and augmentations
License: MIT
Requires Python: >=3.8

# Hyso

Hyso is a PyTorch-based deep learning library designed for **CNN + Bottleneck Residual + CBAM** architectures. It simplifies building, training, and evaluating image classification models with integrated callbacks and data augmentation.

## Project Structure

````bash
hyso/
│
├─ hyso/
│ ├─ models/
│ │ ├─ bcam_model.py # CNNWithBottleneckResidualCBAM
│ │ └─ bcam_fit.py # BCAMWithFit (fit + callbacks)
│ │
│ ├─ augmentation/
│ │ └─ get_loaders.py # Data loader and augmentations
│ │
│ ├─ callbacks/
│ │ └─ callbacks.py # EarlyStopping, ModelCheckpoint, LRSchedulerCallback
│ │
│ └─ init.py
│
├─ setup.py # Installation script
└─ README.md # Project documentation


---

## Features

- CNN with **Bottleneck Residual + CBAM** blocks
- `fit()` and `callbacks()` integration for simplified training
- EarlyStopping, ModelCheckpoint, and LR Scheduler support
- Flexible data loading and augmentation via `get_loaders()`
- EMA support for smoother training (optional)

---

## Installation

### From PyPI (future)
```bash
pip install hyso

````

## From GitHub

git clone https://github.com/huseyin-dgn/hyso.git
cd hyso
pip install .

## Usage

```python
from hyso.models.bcam_fit import BCAMWithFit
from hyso.augmentation.get_loaders import get_loaders

# ---------------- Dataset ----------------
train_loader, val_loader = get_loaders(
    train_path="path/to/train",
    val_path="path/to/val",
    batch_size=64,
    img_size=(32,32),
    augment="advanced",
    channels=3
)

# ---------------- Model ----------------
model = BCAMWithFit(input_channels=3, num_classes=10)

# ---------------- Training ----------------
model.fit(
    train_loader=train_loader,
    val_loader=val_loader,
    scheduler="StepLR",
    scheduler_params={"step_size":5,"gamma":0.5},
    early_stopping=5,
    checkpoint_path="best_bcam_model.pth",
    epochs=20
)
```

## Callbacks

- Hyso supports the following callbacks to improve training:

- EarlyStopping: Stops training if validation loss stops improving.

- ModelCheckpoint: Saves the best model weights.

- LRSchedulerCallback: Automatically adjusts the learning rate based on the chosen scheduler.

Example integration:

```python
model.callbacks(
    optimizer="Adam",
    scheduler="StepLR",
    scheduler_params={"step_size":5,"gamma":0.5},
    model_checkpoint=True,
    earlystop={"patience":5, "verbose":True}
)
```

## Model Summary

To view a Keras-style summary of your model:

```python
from torchsummary import summary
summary(model.model, input_size=(3, 32, 32))
```

## Contributing

Pull requests, bug reports, and feature requests are welcome!

## License

No license is set. Free to use.