grammar corrector python

Python Spelling and Grammar Checkers

Using Python, you can check whether a sentence is correct in an automated manner, and provide suggestions for fixing up bad spelling and grammar. Processing text in this manner falls under the category of natural language processing (NLP). This article provides documentation on how to use Sapling as a Python spelling and grammar checker. Compare it to a list of a few other open-source Python libraries that might be more suitable for individual, non-commercial or open-source projects. For each library, check out the installation guide as well as some sample quick-start Python code that demonstrates how to use each SDK.

Sapling offers a deep neural network language model trained on millions of sentences. Outside of English, it also supports more than 10 different other languages in its language model and regular spell checking for more than 30 other languages . This style of automated proofreading can identify fluency improvements as well as areas where a correct English word was used but would be considered incorrect in the context of the sentence.

For use cases that have security, privacy, or regulatory requirements, Sapling is HIPAA compliant, SOC2 compliant, and offers options for no-data retention or on-premise/self-hosted models. The on-premise version allows users to host the Sapling service in their own cloud or infrastructure so that processed data will stay in a specific geographical region or compute environment.

Get an API key for free and use it for testing or personal use. The free API key comes with limits on usage. The paid version of Sapling’s API has no throttling limits and costs money based on usage.

Sapling’s Python grammar checker is licensed by Apache 2.0: there are no restrictions on how you can use it. This license makes Sapling compatible with commercial software products that want to keep their code proprietary. An alternative JavaScript library also exists for backend applications that use a JavaScript runtime environment like Node.js, or for applications that have an HTML or web-based front end and process text from textareas and content editables. Sapling also has an HTTP API that can be called using other languages directly like PHP or Ruby (or any scripting language that supports HTTP POST and GET requests).

Installing Sapling

• Visit  Sapling.ai to register an account.
• Visit the  dashboard to generate an API key.
• Install Sapling’s SDK:

If you don’t have pip, you can follow the instructions here to install it: https://pip.pypa.io/en/stable/installation/

Sapling Usage

You can read more in:

• Python Docs: https://sapling.readthedocs.io/en/latest/api.html
• Sapling Developer Docs: https://sapling.ai/docs

Open Source Libraries and Licenses

Before we discuss the next section of open source grammar checkers, take a quick overview of the licenses below. If you are familiar with open-source software licenses, you can skip this section.

For developers producing non-commercial products (like personal or research projects), open-source libraries may be a good choice. These are free and configurable. The trade-off between free and better performance or support may be an obvious one for those with budget constraints; however, it is also important to understand the restrictions.

Most open-source software licenses give users permission to modify and distribute the library in question. The open-source licenses for the Python grammar checkers on this list require modifications to the original code to be released publicly and under the same license.

• GNU Lesser General Public License (LGPL): Programs that incorporate LGPL code also need to be LGPL. You can get around this limitation by dynamically linking to LGPL code. If the LGPL code is ever distributed to an end user, the user needs to be able to re-link the application to their own version of the LGPL library. This can work on platforms that allow for library changes, like Windows, MacOS, Linux, but is not possible for others, like iOS. When building an internal tool, or a purely server-based SaaS tool, the distribution clause does not apply.
• Mozilla Public License (MPL): MPL is more permissive and allows for static linking of libraries. There are no re-linking requirements. This permissive license is easier to integrate into a commercial software product compared to GPL and LGPL.
• BSD, MIT, Apache: These licenses are permissive and grant use, distribution and relicensing rights, making them the easiest to use with commercial products.

LanguageTool

LanguageTool is an open-source (LGPL) rules-based grammar checker. It is available as a cloud HTTP end-point hosted by the LanguageTool company. This version has a free offering that has usage (20 requests per minute) and correction limits (30 misspelled words), as well as a paid offering with less restrictions. The cloud offering is currently neither SOC2 nor HIPAA compliant. You can also run the Java backend yourself and call it through Python bindings; however, having to maintain and run a separate Java server or process along with using the Python grammar checker client makes maintenance more complicated.

LanguageTool comes with a database of community-curated grammar rules for different languages. Keep in mind that some of the other languages may not have as good of grammar rule coverage as English does.

Installing LanguageTool Backend

Local hosting of the backend is optional but can help keep text processing local for privacy and security reasons.

• Download the Java executable: https://languagetool.org/download/LanguageTool-stable.zip
• Install Java: https://www.java.com/en/download/help/download_options.html
• Run the LanguageTool Backend:

Installing LanguageTool Python Client

Languagetool usage.

If you are looking for an alternative open source python grammar checker that utilizes the LanguageTool API:

• language-check: https://github.com/myint/language-check/
• pyLanguagetool: https://github.com/Findus23/pyLanguagetool

Hunspell is a popular open-source spell checker that you have likely come across before because it is integrated by default into Firefox, Chrome, and LibreOffice. It has extended support for unicode and language peculiarities like compounding and complex morphology. The name of the library comes from the fact that it is based on MySpell and works with MySpell dictionaries. One of the first languages supported was Hungarian. This is a good spell checker to integrate if you value a library that is widely used and is actively maintained.

Hunspell is written in C++ but you can use it in Python as a spell checker through Cython bindings. Hunspell is licensed under 3 separate licenses: GPL/LGPL/MPL. The MPL license makes Hunspell more permissive and easier to integrate into commercial products compared to Aspell, another spell checker which we will describe later.

Installing Hunspell

Installing hunspell python bindings, hunspell usage.

Aspell is an open-source spell checker that performs slightly better than Hunspell. In addition to spell checking, Aspell also has built-in functionality to suggest alternatives to words, even if they exist in the dictionary. These suggestions can be used to capture issues where a dictionary word is written, but may not be the intended word or is incorrect in context. Keep in mind though that Aspell does not do full grammar checking. While Aspell is a C++ library, you can use as a Python spelling checker through C++ bindings.

The wider adoption of Hunspell over Aspell is most likely due to Aspell being licensed under LGPL, which is less permissive than MPL. If you are building a non-commercial or backend Python application, Aspell is likely a better choice than Hunspell.

Install Aspell

Install an aspell dictionary, install aspell python bindings, aspell usage, building your own.

Grammar checkers are more complex to build from the ground up, they require either maintaining a database of rules for matching against or enough data to train an effective machine-learning language model. Nowadays the most effective models are based off of neural nets, but statistical models can also be trained. Both the training and maintenance of your own grammar checker can be expensive. This path is preferable only if you want to invest in you or your team’s expertise in natural language processing.

Building a Spelling Checker

Building a spell checker in Python that takes text and suggests spelling corrections for words can be done in fewer than 50 lines of code. Starting with a dictionary or a list of words, the algorithm looks up each word in the sentence. For words that are not in the dictionary, suggestions are generated based on edit distance (the number of characters that need to change) compared to dictionary words. If only a couple suggestions are shown, they are prioritized assuming that words that are lower in edit distance are more likely to be the intended word.

An example of this algorithm and relevant Python code has been posted by Peter Norvig, a prominent AI computer scientist, and author of the most popular AI textbook “ Artificial Intelligence: A Modern Approach  “. You can read about his approach here: “How to Write a Spelling Corrector .

Building a Statistical based Grammar Checker

Statistics-based grammar checkers share very similar architectures to Statistical Machine Translation. They break down words and phrases into statistical likelihoods and use that to predict whether sentences are correct or incorrect. If replacement words or phrases are deemed to be statistically more likely, corrections can be suggested.

Symspell is an MIT licensed spell correction and fuzzy search library. The original library is written in C#, but various Python ports of the library exist; some of them are linked in the original repository here https://github.com/wolfgarbe/SymSpell . This library can be used to train a statistical model on text and then used as a spell checker.

Building a Neural Network based Grammar Checker

The neural network based grammar checker shares the same architecture as Neural Machine Translation. The steps required to build such a library from scratch are outside the scope of this blog post. However, some Python frameworks exist that can be used with pre-trained models. An example of this is the happy-transformer: https://github.com/EricFillion/happy-transformer . Other frameworks like PyTorch and TensorFlow can also be used to train your own language models.

The Best Python Spelling and Grammar Checker

Finding the optimal Python spelling and grammar checker will depend on your project requirements. Python’s support for HTTP POST and GET operations means that you can also use a non-Python HTTP API for this purpose. Popular grammar-checking services like Grammarly that do not have a Python or HTTP API were also not included. Likewise, we excluded spelling and grammar check APIs that do not provide Python support from this overview. You can visit this page for a comparison of JavaScript spelling and grammar checkers.

Related Posts

Top 5 Figma Grammar & Spelling Checkers

7 Best AI Copywriting Tools to Boost Your Content Production (2023)

Best Rich Text Editor Libraries

Write a comment cancel reply.

Save my name, email, and website in this browser for the next time I comment.

Type above and press Enter to search. Press Esc to cancel.

• Free Python 3 Tutorial
• Control Flow
• Exception Handling
• Python Programs
• Python Projects
• Python Interview Questions
• Python Database
• Data Science With Python
• Machine Learning with Python
• How to Terminate a running process on Windows in Python?
• Whirlpool Hash Function in Python
• Automated software testing with Python
• How to call C / C++ from Python?
• Python - Get Hardware and System information using platform module
• Python | time.mktime() method
• Python | time.clock_gettime() method
• Python | time.clock_gettime_ns() method
• Python | time.clock_settime() method
• Python | time.clock_settime_ns() method
• File Searching using Python
• Automate getter-setter generator for Java using Python
• Create Battery Notifier for Laptop using Python
• How to check whether users internet is on or off using Python?
• Python | How to put limits on Memory and CPU Usage
• Create a stopwatch using python
• Introduction and Installation of Uberi/Speechrecognition in Python
• Top 5 Easter Eggs in Python
• Python | Locking without Deadlocks

Grammar Checker in Python using Language-check

Python is an open-source programming language. It offers a vast variety of libraries that provide greater functionalities. The one such library is language_check . The language_check library doesn’t come bundled with Python 3. Instead, you have to manually download it from the command line or download it from the pypi.org and then install it manually.

Installation

To install via pip:

If you are using Python 2, you’ll need to install 3to2 beforehand:

Requirements

• Python v3.3+ (or 2.7)
• Java v6.0 or higher.

The language_check specifies the mistakes along with Rule Id, Message, Suggestion, and line number in the document. Also using this we can directly correct the mistakes in the file only. It points out the mistakes accurately but it doesn’t guarantee 100% success in finding mistakes. Sometimes it may happen that it misses out some important mistake. So relying on it completely is not advisable. Below python code demonstrates the use of language_check on Text Document. 

No. of mistakes found in document is 3 Line 1, column 1, Rule ID: UPPERCASE_SENTENCE_START Message: This sentence does not start with an uppercase letter Suggestion: So as you can see buying a new car doesn’t… ^^ Line 1, column 102, Rule ID: ENGLISH_WORD_REPEAT_RULE Message: Possible typo: you repeated a word Suggestion: research …ing if you’ll follow three simple steps research research research read and find out everything y… ^^^^^^^^^^^^^^^^^ Line 1, column 1025, Rule ID: MORFOLOGIK_RULE_EN_US Message: Possible spelling mistake found Suggestion: speech; spec; specs; speck; spec h …unny way to start the speech and in the speech and now use the listener knew that I’m …

Please Login to comment...

• python-utility
• 10 Best Free Code Learning Apps for Android in 2024
• 5 Best AI Tools for Plagiarism Detection 2024
• 10 Best iMovie Alternatives in 2024
• 10 Best AI Tools for Sentiment Analysis
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

grammar-check 1.3.1

pip install grammar-check Copy PIP instructions

Released: Sep 4, 2015

Checks grammar using LanguageTool.

Project links

• Open issues:

View statistics for this project via Libraries.io , or by using our public dataset on Google BigQuery

License: GNU Lesser General Public License v3 or later (LGPLv3+)

Author: Viraj

Maintainers

Classifiers

• OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
• Python :: 2.7
• Python :: 3
• Python :: 3.2
• Python :: 3.3

Project description

Python wrapper for LanguageTool.

This is a fork of https://github.com/myint/language-check

Example usage

>From the interpreter:

Automatically apply suggestions to the text:

>From the command line:

Installation

To install via pip:

Prerequisites

Project details, release history release notifications | rss feed.

Sep 4, 2015

Sep 2, 2015

Aug 31, 2015

Aug 30, 2015

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages .

Source Distributions

Built distribution.

Uploaded Sep 4, 2015 Python 2

Hashes for grammar_check-1.3.1-py2-none-any.whl

• português (Brasil)

Supported by

Grammar Correction With Transformer Models Made Easy

Grammar correction has many useful applications. Perhaps you wish to improve the quality of your data before fine-tuning a model. Or maybe, you want to provide grammar suggestions to text that a user submits. In either case, you can consider using a model I recently published that allows you to produce a grammatically correct version of inputted text. You don't need any prior experience in AI or natural language processing (NLP) to follow this tutorial. All you need is a simple understanding of Python, so let's get right to it!

We'll use a fine-tuned version of Google's T5 model. T5 is a text-to-text model, meaning given text, it produces a standalone piece of text. It is currently considered "state-of-the-art," and the largest model even outperforms the human baseline on the General Language Understanding Evaluation benchmark. The T5 model we'll use was fine-tuned on a dataset called the JHU FLuency-Extended GUG corpus , which is a renowned grammar correction dataset within the NLP community

The model is available on Hugging Face's model hub and can be implemented with just a few lines of code using a Python package I am the lead maintainer of called Happy Transformer . You can learn how to fine-tune your own grammar correction model within this article and I encourage you to publish your own grammar correction models to Hugging Face's model hub to help advance the NLP community.

Installation

Happy Transformer is available on PyPI and thus can be installed with a simple pip command.

As I said, we'll use a T5 model, which is known as a "text-to-text" model. Thus, we'll import a class from Happy Transformer that allows us to use text-to-text models called "HappyTextToText."

We can now download and initialize the model from Hugging Face’s model hub with the following line of code. Notice how we provide the model type in all caps to the first position input and the model name to the second.

Let's initialize settings to generate text. We'll import a class called TTSettings and instantiate an object that contains the proper settings to use a generation algorithm called "beam search." You can learn more about the different text generation settings on this webpage .

Now, let’s create text that contains multiple grammatical mistakes so that we can correct it using the model. We must add the prefix “grammar: ” to the text to indicate the task we want to perform.

From here, we can simply call happy_tt's generate_text method and provide both the text and the settings.

Result: I want to code.

Result: Your laptop is broken.

You just learned how to implement a state-of-the-art AI model to perform grammar correction. Here's a Colab file that contains all of the code covered in this tutorial.  I suggest you play around with the Colab file and provide the model with your own inputs. Also, to enhance your learning, I suggest you fine-tune your own grammar correction model, which you can learn how to do within this article . Training your own grammar model is really quite easy due to how Happy Transformer abstracts the complexes that are typically involved with fine-tuning Transformer models. I hope you learned something useful and stay happy everyone!

Interested in networking with fellow NLP enthusiast or have a question? Then join Happy Transformer's Discord community

Support Happy Transformer by giving it a star 🌟🌟🌟

Fine-tuning article

You might also like...

Llama-2 made easy. fine-tune and perform inference with a transformer model, keywords to text with gpt-neo, three text classification techniques that require little to no data, keyword extraction with keybert, topic modelling with bertopic.

4 Ways to Correct Grammar with Python

This tutorial explains various methods for checking and correcting grammar using Python. Automatic grammar correction helps students, professionals and content creators to make sure their writing follows proper grammar rules.

1. LanguageTool

We can use LanguageTool in python using the library language-tool-python . It is an open source tool to check grammar and spelling mistakes which means it is available for free without any registration.

To install the python library for LanguageTool, run the command below.

Let's take a sample text to explain this library with an example.

In the program below, we are loading the library first and then running the library on input text. It returns the corrected text after fixing spelling mistakes and grammar.

In the previous section, it automatically corrects grammar in the sentence. Here we are interested to see the grammar and spelling mistakes in the text along with the replacements suggested by the tool.

To see the number of errors, use the code below.

To see the detailed description of the first issue in the text, use the command below.

To see the replacements suggested by the tool for the first issue, use the command below.

To simplify the output, extract only grammatical errors and their suggested corrections from the output.

In the program above, we used American English (en-US) as a language to detect grammar and spelling errors in the text. You can use other variants of English as follows.

• en-CA: Canadian English
• en-AU: Australian English
• en-NZ: New Zealand English
• en-GB: British English
• en-ZA: South African English

The library supports many languages other than English as shown below. To detect the language automatically, you can use auto language code.

2. Gramformer

Gramformer is an open source python library based on some of the top notch researches in grammar correction. It has several models which can detect, highlight and correct grammar errors.

Make sure to install libraries such as torch and spacy along with Gramformer.

To correct grammar automatically in the text, run the program below.

To highlight grammar issues in the text along with its solutions, run gf.correct first and pass the output of it with the input text to gf.highlight method.

Ginger Software allows you to check and correct grammar in Python via its API. It offers both free and paid versions. The free version has a limit of 2000 sentences per month and you need to subscribe before using it.

To get your API key, you need to visit the Ginger Software Page on the RapidAPI website .

Make sure the requests library is installed before using the program below. In the following code, don't forget to enter your API key in the API variable.

4. pyaspeller

pyaspeller is a python library to correct spelling mistakes but is unable to correct grammar. You can install this library by using the command pip install pyaspeller .

Deepanshu founded ListenData with a simple objective - Make analytics easy to understand and follow. He has over 10 years of experience in data science. During his tenure, he worked with global clients in various domains like Banking, Insurance, Private Equity, Telecom and HR.

Spelling Correction in Python with TextBlob

• Introduction

Spelling mistakes are common, and most people are used to software indicating if a mistake was made. From autocorrect on our phones, to red underlining in text editors, spell checking is an essential feature for many different products.

The first program to implement spell checking was written in 1971 for the DEC PDP-10 . Called SPELL, it was capable of performing only simple comparisons of words and detecting one or two letter differences. As hardware and software advanced, so have spell checkers. Modern spell checkers are capable of handling morphology and using statistics to improve suggestions.

Python offers many modules to use for this purpose, making writing a simple spell checker an easy 20-minute ordeal.

One of these libraries being TextBlob , which is used for natural language processing that provides an intuitive API to work with.

In this article we'll take a look at how to implement spelling correction in Python with TextBlob .

• Installation

First, we'll need to install TextBlob , since it doesn't come preinstalled. Open up a console and install it using pip :

This should install everything we need for this project. Upon finishing the installation, the console output should include something like:

TextBlob is built on top of NLTK, so it also comes with the installation.

• The correct() Function

The most straightforward way to correct input text is to use the correct() method. The example text we'll be using is a paragraph from Charles Darwin's "On the Origin of Species", which is part of the public domain, packed into a file called text.txt .

In addition, we'll add some deliberate spelling mistakes:

It's full of spelling mistakes, in almost every word. Let's write up a simple script, using TextBlob, to correct these mistakes and print them back to the console:

If you've worked with TextBlob before, this flow will look familiar to you. We've read the file and the contents inside of it, and constructed a TextBlob instance by passing the contents to the constructor.

Then, we run the correct() function on that instance to perform spelling correction.

After running the script above, you should get an output similar to:

• How Correct is TextBlob's Spelling Correction?

As we can see, the text still has some spelling errors. Words like "abl" were supposed to be "able" , not "all" . Though, even with these, it's still better than the original.

Now comes the question, how much better is it?

The following code snippet is a simple script that test how good is TextBlob in correcting errors, based on this example:

Now, with those two functions, let's run a quick analysis:

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

Running it will print out:

As we can see, the correct method managed to get our spelling mistake percentage from 60.6% to 15.9%, which is pretty decent, however there's a bit of a catch. It corrected 54.7% of the words, so why is there still a 15.9% mistake rate?

The answer is overcorrection . Sometimes, it can change a word that is spelled correctly, like the first word in our example text where "As" was corrected to "Is" . Other times, it just doesn't have enough information about the word and the context to tell which word the user was intending to type, so it guesses that it should replace "whl" with "while" instead of "whole" .

There is no perfect spelling corrector because so much of spoken language is contextual, so keep that in mind. In most use cases, there are way fewer mistakes than in our example, so TextBlob should be able to work well enough for the average user.

• Training TextBlob with Custom Datasets

What if you want to spellcheck another language which isn't supported by TextBlob out of the box? Or maybe you want to get just a little bit more precise? Well, there might be a way to achieve this. It all comes down to the way spell checking works in TextBlob.

TextBlob uses statistics of word usage in English to make smart suggestions on which words to correct. It keeps these statistics in a file called en-spelling.txt , but it also allows you to make your very own word usage statistics file.

Let's try to make one for our Darwin example. We'll use all the words in the "On the Origin of Species" to train. You can use any text, just make sure it has enough words that are relevant to the text you wish to correct.

In our case, the rest of the book will provide great context and additional information that TextBlob would need to be more accurate in the correction.

Let's rewrite the script:

If we look into the train.txt file, we'll see:

This indicates that the word "a" shows up as a word 3389 times, while "ably" shows up only 5 times. To test out this trained model, we'll use suggest(text) instead of correct(text) , which is a list of word-confidence tuples. The first element in the list will be the word it's most confident about, so we can access it via suggest(text)[0][0] .

Note that this might be slower, so go word by word while spell-checking, as dumping huge amounts of data can result in a crash:

And now, this will result in:

This fixes around 2 out of 3 of misspelled words, which is pretty good, considering the run without much context.

In this article we'll used TextBlob to implement a basic spelling corrector, both with the stock prediction model a custom one.

Correcting man-made spelling errors has become a common task for software developers. Even though it has become easier and more efficient via data mining, many spelling mistakes need context to be corrected.

In conclusion, proofreaders are probably not going to get automated out of work any time soon, though some basic corrections can be automated to save time and effort.

You might also like...

• Simple NLP in Python with TextBlob: N-Grams Detection
• Simple NLP in Python With TextBlob: Tokenization
• Sentiment Analysis in Python With TextBlob
• Keras Callbacks: Save and Visualize Prediction on Each Training Epoch
• The Best Machine Learning Libraries in Python

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

CS student with a passion for juggling and math.

In this article

Image Captioning with CNNs and Transformers with Keras

In 1974, Ray Kurzweil's company developed the "Kurzweil Reading Machine" - an omni-font OCR machine used to read text out loud. This machine...

Building Your First Convolutional Neural Network With Keras

Most resources start with pristine datasets, start at importing and finish at validation. There's much more to know. Why was a class predicted? Where was...

© 2013- 2024 Stack Abuse. All rights reserved.

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

a free python grammar checker 📝✅

jxmorris12/language_tool_python

Contributors 18.

• Python 96.2%
• Makefile 0.8%

• Python »
• 3.12.2 Documentation »
• The Python Language Reference »
• 10. Full Grammar specification
• Theme Auto Light Dark |

10. Full Grammar specification ¶

This is the full Python grammar, derived directly from the grammar used to generate the CPython parser (see Grammar/python.gram ). The version here omits details related to code generation and error recovery.

The notation is a mixture of EBNF and PEG . In particular, & followed by a symbol, token or parenthesized group indicates a positive lookahead (i.e., is required to match but not consumed), while ! indicates a negative lookahead (i.e., is required not to match). We use the | separator to mean PEG’s “ordered choice” (written as / in traditional PEG grammars). See PEP 617 for more details on the grammar’s syntax.

Previous topic

9. Top-level components

The Python Standard Library

• Report a Bug
• Show Source