pathfinding_challenge 1.0.1
Fuel Efficiency Pathfinding System Challenge
Requires Python: <4.0.0,>=3.10.4

# Fuel Efficiency Pathfinding Challenge

[![CI](https://github.com/lucas-althoff/BeesDataChallenge_ML/actions/workflows/pipeline.yml/badge.svg)](https://github.com/lucas-althoff/BeesDataChallenge_ML/actions/workflows/pipeline.yml/)
[![PyPI version](https://img.shields.io/pypi/v/pathfinding_challenge?label=pypi%20package)](https://pypi.org/project/pathfinding_challenge)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/pathfinding_challenge)](https://pypi.org/project/pathfinding_challenge/#history)

# Installing

For installing the package you have to execute:

```bash
pipx install pathfing_challenge
```

or your preferable package management system

```bash
pip install pathfing_challenge
```

# Test coverage

The coverage is on 99%, the complete html report can be found at: 
[coverage report](https://github.com/lucas-althoff/BeesDataChallenge_ML/tree/master/htmlcov/index.html)

# About

Our solution focus on solving path finding with a path cost based on two attributes, the distance between two coordinates and
the terrain fuel consumption.

The package has two libraries:

- algorithms
- entities

Two path finding algorithms can be applied to solve a grid specific:

- A*
- Djikstra

## Execution

You can execute a random grid example running:
```python
from pathfinding_challenge.algorithms.example import PFC

pf = PFC()
pf.run_example()
```

## License
**MIT**


## Author

Lucas S. Althoff [@lucas-althoff](https://github.com/lucas-althoff) <ls.althoff@gmail.com>

---

## Overview

Welcome to the Fuel Efficiency Path Challenge! In this coding exercise, you are tasked with implementing a series of entities and algorithms to map the most fuel-efficient path through various terrains. This challenge is designed to assess your skills in algorithm implementation, object-oriented programming, and problem-solving.

**NOTE**: Do NOT modify the tests in the `tests` folder. These tests are used to verify your code and should not be changed.

## Solution Submission
Ensure your submission is zipped/compressed, does NOT change the tests, AND includes your `.git` file.

## Challenge Description

Your mission involves two key components: `entities` and `algorithms`. These are represented as two separate folders in the repository. Each folder contains files that define the structure and requirements of components you need to implement.

### Entities

The `entities` folder contains definitions for different objects in a grid that represents various terrains. Your task is to implement the functionality of these entities. The entities include:

- `DownHill`
- `Valley`
- `Position`
- `UpHill`
- `Node`
- `Plateau`

Each of these entities plays a role in the simulation of a vehicle moving through different terrains, affecting its fuel efficiency.

### Algorithms

The `algorithms` folder includes files that describe algorithms for pathfinding. These algorithms will be used to determine the most efficient path through the grid considering the different terrains. The algorithms you need to implement are:

- `Dijkstra`
- `PathFinding`
- `AStar`

You will need to understand and implement these algorithms to find the optimal path in terms of fuel efficiency.

## Testing

To assist you in this challenge, a suite of tests is provided. These tests will guide you through the implementation process and ensure your code meets the specified requirements. The tests can be found in the `tests` folder.

# CI/CD Implementation Requirements

As part of this project, you are required to set up a Continuous Integration and Continuous Deployment (CI/CD) pipeline using GitHub Actions. This pipeline will automate the testing and deployment of your code.

## Workflow Steps

1. **Testing with pytest**: Upon each push or pull request to the main branch, the CI pipeline should automatically execute tests using pytest. This ensures that all new changes are verified before deployment.

2. **Building the Package**: If the tests pass, the next step is to build the Python package. This process involves preparing the package for distribution, ensuring that it is ready for deployment to PyPI.

3. **Creating a GitHub Workflow Artifact**: After successful deployment to PyPI, create a downloadable artifact of your package within the GitHub Workflow. This artifact should be accessible from the GitHub Actions run, allowing users to directly download the package version from GitHub.

## Good Luck!

We look forward to seeing your innovative solutions to this unique and challenging problem. Good luck, and happy coding!

# Rubric for Fuel Efficiency Path Challenge

### Total Points: 100

#### 1. Implementation of Entities (30 points)
   - `DownHill` Implementation: 5 points
   - `Valley` Implementation: 5 points
   - `Position` Implementation: 5 points
   - `UpHill` Implementation: 5 points
   - `Node` Implementation: 5 points
   - `Plateau` Implementation: 5 points

#### 2. Implementation of Algorithms (30 points)
   - `Dijkstra` Algorithm Implementation: 15 points
   - `PathFinding` Algorithm Implementation: 15 points

#### 3. Code Quality and Style (10 points)
   - Readability: 5 points
   - Adherence to coding standards/conventions: 5 points

#### 4. Testing and Test Coverage (20 points)
   - Comprehensive test cases: 10 points
   - Test coverage (measured using a tool like `coverage.py`): 10 points

#### 5. CI/CD Pipeline Implementation (10 points)
   - Correct setup of GitHub Actions for pytest: 3 points
   - Successful building and packaging of the Python package: 3 points
   - Creation of a downloadable GitHub Workflow artifact: 4 points