This repository contains the source code of an independent machine learning module used to classify images received from the backend API. The overall goal of this module is to replace Custom Vision. This will lead to more control from the developers aspect in terms of how the machine learning model is built, and may assist in gaining relevant information on what's going on inside the model itself.
Guide on how to use/run the program comes here!
Guide on how to get started with development comes here!
Guide to required installations comes here!
To make the code as easy to maintain and read as possible, it is necessary to follow some conventions. These conventions should be followed as strictly as possible to ensure that the process of code reviewing is as easy as possible.
- Use Pep8 as standard formatting for the code.
- Ensure that the code is properly formatted before creating a merge request.
- Avoid using magic numbers in the code. Create and retrieve variables through configuration files instead.
- Comment the code properly when needed.
- Include docstrings in functions where it's necessary, preferably always.
- Develop tests when a new feature is implemented.
- Don't EVER use 'import *'
- Leave an empty line at the end of a statement, loop or a similiar code structure.
- Don't use more than 1 newline between code chunks within functions/methods.
- When creating strings, use double quotation marks ("string here") instead of single ('string here').
- The triple quotations in a docstring should be on separate lines from the content. Remember to indent the content of the docstring as well. This makes it more readable.
- Ideally, only a single class should be placed within each file.
- Ensure that method names use underscores between words instead of camel case.
- Capitalize the Subject.
- Do not end the Subject line with a period.
- Use the present tense ("Add feature" not "Added feature").
- Use the imperative mood ("Move cursor to..." not "Moves cursor to...").
- Use the message body to explain what and why vs. how.
A rule of thumb when working on the project is to always branch out to a new branch when something is to be added. In general, developers shouldn't be able to push to master and therefore rely on submitting pull requests to put new features on the master branch.
- Use appropriate branch naming convention when creating a new branch (see the table below).
- Create a new branch whenever something new is to be added.
- Delete the branch when it has been successfully merged with the master branch.
- Avoid repeating the same branch name over and over again.
| Naming | When to use? |
|---|---|
feature/awesome-branch-name |
When developing a new feature |
bugfix/awesome-branch-name |
When fixing a bug |
docs/awesome-branch-name |
When updating documentation |
refactoring/awesome-branch-name |
When refactoring code |
testing/awesome-branch-name |
When writing new tests to existing features |
When an issue has been solved and tested by the developer, a pull request must be submitted in the repository for validation. This is so the branch can be merged with the master branch. The Merge Request must follow the rules given below.
- Don't use the branch name as header for the pull request.
- Use a header called "Changes" where you explain pointwise what the pull requests add to the project.
- Add a header called "notes" where you explain things that may need attention, e.g if anything isn't finished, if something is broken etc.
- Remember to rebase before creating the pull request.
- There must be at least 2 approvals before the request can be merged.
- The developer submitting the Merge Request is not allowed to approve the request (his/her vote doesn't count).
- If the pull request resolves an issue submitted in the repository, the issue should be tagged in the pull request.
- Use valid emojis to make the pull request more fun to read (not required, but recommended).
We generally want to write issues to keep track of tasks that need to be done. This means that if something is either lacking, or broken in the program, an issue can be submitted with a description of what needs to be done.
- Be precise about what is needed to be done:
1.1. What: Frontend, Backend, etc.
1.2. Where: File that needs to be changed (also potentially function that needs editing).
1.3. How: Potential solution or if a certain requirement must be satisfied (this can be vague, and may not be needed). - Don't describe multiple issues.
- Follow the commit message rules when writing an issue.
- The issue should be split up into two sections: One which explains the issue point-wise (if necessary), the second is for notes explaining potential solutions.
When rebasing, you will go through the commit history in your current branch and the master branch and sequentially pick what conflicting code to keep. You will do this after step 2 and step 4. Note that step 4 and step 5 may be repeated for each commit in the branch.
- git checkout <branch_name>
- git rebase master
- git add .
- git rebase --continue
- git add .
- git push --force