Contributing

Contributions are welcome, and they are greatly appreciated! Every little bit helps, and credit will always be given.

You can contribute in many ways:

Types of Contributions

Report Bugs

Report bugs at https://github.com/khushaljethava/createllm/issues.

If you are reporting a bug, please include:

  • Your operating system name and version.

  • Any details about your local setup that might be helpful in troubleshooting.

  • Detailed steps to reproduce the bug.

Fix Bugs

Look through the GitHub issues for bugs. Anything tagged with “bug” and “help wanted” is open to whoever wants to implement it.

Implement Features

Look through the GitHub issues for features. Anything tagged with “enhancement” and “help wanted” is open to whoever wants to implement it.

Write Documentation

createllm could always use more documentation, whether as part of the official createllm docs, in docstrings, or even on the web in blog posts, articles, and such.

Submit Feedback

The best way to send feedback is to file an issue at https://github.com/khushaljethava/createllm/issues.

If you are proposing a feature:

  • Explain in detail how it would work.

  • Keep the scope as narrow as possible, to make it easier to implement.

  • Remember that this is a volunteer-driven project, and that contributions are welcome :)

Get Started!

Ready to contribute? Here’s how to set up createllm for local development.

  1. Fork the createllm repo on GitHub.

  2. Clone your fork locally:

    $ git clone git@github.com:your_name_here/createllm.git

  3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development:

    $ mkvirtualenv createllm
$ cd createllm/
$ python setup.py develop

  4. Create a branch for local development:

    $ git checkout -b name-of-your-bugfix-or-feature

    Now you can make your changes locally.

  5. When you’re done making changes, check that your changes pass flake8 and the tests, including testing other Python versions with tox:

    $ make lint
$ make test
Or
$ make test-all

    To get flake8 and tox, just pip install them into your virtualenv.

  6. Commit your changes and push your branch to GitHub:

    $ git add .
$ git commit -m "Your detailed description of your changes."
$ git push origin name-of-your-bugfix-or-feature

  7. Submit a pull request through the GitHub website.

Pull Request Guidelines

Before you submit a pull request, check that it meets these guidelines:

  1. The pull request should include tests.

  2. If the pull request adds functionality, the docs should be updated. Put your new functionality into a function with a docstring, and add the feature to the list in README.rst.

  3. The pull request should work for Python 3.5, 3.6, 3.7 and 3.8, and for PyPy. Check https://travis-ci.com/khushaljethava/createllm/pull_requests and make sure that the tests pass for all supported Python versions.

Tips

To run a subset of tests:

$ python -m unittest tests.test_createllm

Deploying

A reminder for the maintainers on how to deploy. Make sure all your changes are committed (including an entry in HISTORY.rst). Then run:

$ bump2version patch # possible: major / minor / patch
$ git push
$ git push --tags

Travis will then deploy to PyPI if tests pass.

Code of Conduct

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Thank you for your interest in contributing to createllm! This document provides guidelines and instructions for contributing to the project.

Development Setup

1. Fork and Clone

First, fork the repository and clone your fork:

git clone https://github.com/your-username/createllm.git
cd createllm

2. Install Development Dependencies

Install the package in development mode with all dependencies:

pip install -e ".[dev]"

This will install: * coverage - for testing coverage * mypy - for type checking * pytest - for running tests * ruff - for linting

3. Set Up Pre-commit Hooks

Install pre-commit hooks to ensure code quality:

pre-commit install

Development Guidelines

1. Code Style

  • Follow PEP 8 guidelines

  • Use type hints for all function parameters and return values

  • Keep functions focused and single-purpose

  • Write clear and descriptive variable names

  • Add docstrings for all public functions and classes

2. Testing

  • Write tests for new features

  • Ensure all tests pass before submitting PR

  • Maintain or improve test coverage

  • Include both unit and integration tests

3. Documentation

  • Update documentation for new features

  • Add docstrings following Google style

  • Include examples in docstrings

  • Update README.md and README.rst if needed

4. Git Workflow

  • Create a new branch for each feature/fix

  • Use descriptive branch names

  • Write clear commit messages

  • Keep commits focused and atomic

Making Changes

1. Create a New Branch

git checkout -b feature/your-feature-name
# or
git checkout -b fix/your-fix-name

2. Make Your Changes

  • Write your code

  • Add tests

  • Update documentation

  • Run tests and linting

3. Commit Your Changes

git add .
git commit -m "Description of your changes"

4. Push to Your Fork

git push origin feature/your-feature-name

5. Create a Pull Request

  • Go to the GitHub repository

  • Click “New Pull Request”

  • Select your branch

  • Fill in the PR template

  • Submit the PR

Pull Request Guidelines

1. Title and Description

  • Use clear and descriptive titles

  • Fill in the PR template completely

  • Include: - Purpose of changes - Implementation details - Testing done - Screenshots (if applicable)

2. Code Review

  • Address all review comments

  • Keep the PR focused and manageable

  • Update documentation as needed

  • Ensure CI checks pass

3. Merging

  • Get approval from maintainers

  • Ensure all checks pass

  • Keep commits clean and organized

  • Update version if needed

Testing Guidelines

1. Running Tests

# Run all tests
pytest

# Run with coverage
pytest --cov=createllm

# Run specific test file
pytest tests/test_model.py

2. Writing Tests

  • Test both success and failure cases

  • Use appropriate fixtures

  • Mock external dependencies

  • Test edge cases

3. Test Coverage

  • Maintain or improve coverage

  • Focus on critical paths

  • Test public API thoroughly

  • Include integration tests

Documentation Guidelines

1. Code Documentation

  • Add docstrings to all public functions/classes

  • Include type hints

  • Provide usage examples

  • Document exceptions

2. API Documentation

  • Update API reference

  • Add new examples

  • Document breaking changes

  • Keep documentation up to date

3. User Documentation

  • Update user guides

  • Add new tutorials

  • Document new features

  • Include troubleshooting guides

Release Process

1. Version Bumping

  • Update version in: - pyproject.toml - setup.py - __init__.py

  • Follow semantic versioning

2. Changelog

  • Update CHANGELOG.md

  • Document breaking changes

  • List new features

  • Note bug fixes

3. Release Notes

  • Write clear release notes

  • Highlight major changes

  • Include migration guides

  • Document deprecations

Getting Help

If you need help:

  • Check existing issues

  • Ask in discussions

  • Contact maintainers

  • Join the community

Thank You

Thank you for contributing to createllm! Your contributions help make the project better for everyone.