# Contributing

Thank you for taking the time to contribute to Pydantic Pint!
All types of contributions are encouraged and valued.
Please refer to this page for ways to contribute.

## Overview

> There are plenty of ways to support the project and show your appreciation!
>
> - Create and comment on [issues].
> - Create and comment on [pull requests].
> - [Fork] the project.
> - [Star] the project.
> - [Watch] the project.
> - Talk about the project!

## Creating Issues

GitHub [issues] track any enhancements, bugs, questions, or suggestions for this project.

- [Open an issue].
- Provide as much detail as you can.
- Provide project and platform version (python, pydantic, pint, etc.).

#### Asking Questions

If you have a question, create an issue with the `question` label.
We will try to answer it as best we can.

Provide the following information when asking questions.

- Ask the question in a clear and concise manner.
- Search and link relevant issues and pull requests.
- Provide details and context separate from the question.
  In other words, the question and context should be separate.
  This makes it easier to answer the question if it is clearly stated.
  Anything passed that can be a discussion.

#### Requesting Features

If you have an idea for enhancements, open an issue with the `enhancement` label.
We will determine if such an enhancement is worth implementing.
Enhancements should improve the use of the project without breaking the existing functionality.

Provide the following information when requesting features.

- Explain what currently does not exist with the project.
- Explain how the feature request can address the issue.
- Include usecases for the feature.
- Include examples for using the feature.

#### Reporting Bugs

If you find a bug, open an issue with the `bug` label.
Bug reports should contain information about the environment in which you are running.
This is key in order to replicate the issue to further investigate and fix it.

Provide the following information when reporting a bug.

- Environment, including project and platform information (python, pydantic, pint, etc.).
- Current behavior, include examples for replication.
- Expected behavior, include examples for verification.

#### Updating Documentation

If you think the documentation should be updated, open an issue with the `documentation` label.
Documentation might have small issues that need fixed, e.g. misspellings or grammar mistakes, or might be related to enhancements or bugs, e.g. new or changed functionality.

Provide the following information when updating the documentation.

- The documentation page that should be added.
- The documentation page that should be modified.
- The documentation page that should be removed.
- Updates to examples.

## Creating Pull Requests

GitHub [pull requests] address the issues of the project.

- [Fork] the project.
- Create a branch from the latest revision on `main`.
- Implement the changes to address a particular issue(s).
- [Open a pull request].
- Add the issue number to the description of the pull request.
  It should be clear which issue (or issues) are addressed.

#### Fixing Bugs

Fixing a bug should have an associated issue labeled as a `bug`.
Make sure the bug is fixed correctly and completely.
The following additions to your bugfix could help improve it.

- Add unit tests to cover the bugfix.
  This ensures that it never pops back up.
- Test all facets of your changes so that no other parts of the code base breaks.
  Check how the new feature interacts with other features.
- Make sure each commit is deliberate and meaningful.
  Changes like spacing, formatting, or typos (in unrelated locations) are not necessary to change while implementing a feature or bugfix.
  Ensure other parts of the code have not been modified that do not need to be modified to implement your feature or bugfix.
- Limit the size of your changes.
  Large diffs can be difficult to verify and validate.

#### Implementing Features

Implementing a feature should have an associated issue labeled as an `enhancement`.
Make sure the feature is implemented correctly and completely.
The following additions to your feature could help improve it.

- Add documentation.
- Add unit tests.
  Check corner cases, and how the feature works with bad or invalid input.
- Test all facets of your changes so that no other parts of the code base breaks.
  Check how the new feature interacts with other features.
- Make sure each commit is deliberate and meaningful.
  Changes like spacing, formatting, or typos (in unrelated locations) are not necessary to change while implementing a feature or bugfix.
  Ensure other parts of the code have not been modified that do not need to be modified to implement your feature or bugfix.
- Limit the size of your changes.
  Large diffs can be difficult to verify and validate.


## Thank You!

You are help Pydantic Pint grow and prosper with your involvement.
We hope to see your contributions in the project soon!

<!-- links -->
[project]:             https://github.com/tylerh111/pydantic-pint
[star]:                https://github.com/tylerh111/pydantic-pint
[watch]:               https://github.com/tylerh111/pydantic-pint
[fork]:                https://github.com/tylerh111/pydantic-pint/fork
[issues]:              https://github.com/tylerh111/pydantic-pint/issues
[open an issue]:       https://github.com/tylerh111/pydantic-pint/issues/new
[pull requests]:       https://github.com/tylerh111/pydantic-pint/pulls
[open a pull request]: https://github.com/tylerh111/pydantic-pint/compare
[documentation]:       https://pydantic-pint.readthedocs.io
