How to use the Python better_profanity Filter API with GraphQL

As social interaction on the web continues to grow especially as generative AIs continue to gain global adoption, there is an increasing need to build social applications with abilities to detect and filter profane words.

Building applications that can detect and filter profanity could be one of the solutions to safer online social communication and interaction.

In this tutorial, we'll illustrate with code snippets how to build a profanity filter using Python better_profanity API and GraphQL.

What is Profanity

Profanity is the use of swear, rude, and offensive words in conversation. Profanity can be used to express a strong feeling of animosity or disapproval to someone or something.

A profanity filter is an application that detects, and filters words perceived as profane in an online communication channel.

Reasons to detect and filter profanity

To make online spaces safe for social interaction.
To automatically detect and filter unwanted content.
Detecting and filtering profanity improves user experience.
It builds healthy social spaces.

Detecting Profanity with better_profanity

Better-profanity is a blazingly fast Python library to detect and clean swear words. It supports custom word lists, safelists, detecting profanity in modified word spellings, Unicode characters (also called leetspeak), and even multi-lingual profanity detection.

To get started you'll need the following prerequisites:

Python installed on your machine
Basic knowledge of Python
Basic knowledge of GraphQL

Installing better_profanity library

To install the better_profanity library for our project, run the following command in your terminal:

 pip install better_profanity

In your Python project, create a profanity_filter.py file and add the following code snippets:

from better_profanity import profanity

profanity.load_censor_words()


def test_profanity(paragraph):
    print(profanity.censor(paragraph))

If you pass an offensive word as an argument to the function, as shown below:

test_profanity("Don't be fuck")

You would get the following result:

Don't be ****

Python better_profanity has a function that tells whether a string contains a swear word:

profanity.contains_profanity() # True | # False

Python better_profanity has a function that censors swear words with a custom character:

profanity.censor(word, '-')

The second argument in .censor('-') will be used to censor any swear word found in the first argument (word).

Building a GraphQL API for our Profanity Filter

Now we have the profanity filter working, let's build a GraphQL API for our filter and test it.

Installing Flask and GraphQL

To install Flask and GraphQL libraries in our application, on your terminal, run the following command:

pip install Flask Flask_GraphQL graphene

Next, we'll write our API GraphQl schema. To do that, create a schema.py file and add the following code:

import graphene
from better_profanity import profanity


class Outcome(graphene.ObjectType):
    paragraph = graphene.String()
    is_profane = graphene.Boolean()
    censored_paragraph = graphene.String()


class Query(graphene.ObjectType):
    detect_profanity = graphene.Field(Outcome, paragraph=graphene.String(
        required=True), character=graphene.String(default_value="*"))

    def resolve_detect_profanity(self, info, paragraph, character):
        is_profane = profanity.contains_profanity(paragraph)
        censored_paragraph = profanity.censor(paragraph, character)
        return Outcome(
            paragraph=paragraph,
            is_profane=is_profane,
            censored_paragraph=censored_paragraph
        )


profanity.load_censor_words()
schema = graphene.Schema(query=Query)

Next, let's configure our profanity filter to a server with an accessible URL. To do that, create a Python file, app.py, and add the following code to it:

from flask import Flask
from flask_graphql import GraphQLView
from schema import schema

app = Flask(__name__)
app.add_url_rule("/", view_func=GraphQLView.as_view("graphql",
                 schema=schema, graphiql=True))


if __name__ == "__main__":
    app.run(debug=True)

To run our application, run the following command in the terminal:

python app.py

If you do everything right, the server should start running, and your terminal should be like the one in the attached image below:

Now you can test your API by visiting this URL (http://127.0.0.1:5000/) as shown on the terminal.
Vising the URL, you'll see the GraphiQL interface as shown in the image below:

To test the API, execute the following query in the provided GraphQL interface:

{
  detectProfanity(paragraph: "Don't be an asshole", character: "%"){
    paragraph
    isProfane
    censoredParagraph
  }
}

And you'll get the following response:

{
  "data": {
    "detectProfanity": {
      "paragraph": "Don't be an asshole",
      "isProfane": true,
      "censoredParagraph": "Don't be an %%%%"
    }
  }
}

Conclusion

Building a safe social network for all users is an important factor to consider when building social applications. In this tutorial, we introduced the concept of profanity and how to detect and filter profane words in an application. We used the Python framework Flask and GraphQL to illustrate how to build a profanity filter API.

Blog