updated fastapi

.dockerignore

@@ -0,0 +1,25 @@
+# Python specific files and directories
+*.pyc
+*.pyo
+__pycache__/
+.pytest_cache/
+.mypy_cache/
+.venv/
+venv/
+env/
+
+# Editor/IDE specific files
+.vscode/
+.idea/
+*.sublime-project
+*.sublime-workspace
+
+# Common build/distribution files
+dist/
+build/
+*.egg-info/
+.DS_Store
+
+# Git specific files
+.git/
+.gitignore

Dockerfile

@@ -1,43 +1,28 @@
 FROM python:3.10-slim
 
-# Set working directory inside the container
 WORKDIR /app
 
 # Install system dependencies
-# git is included for any potential future needs or if any dependency requires it for cloning
-# Install Java Runtime Environment (JRE) - crucial for language-tool-python
-RUN apt-get update && apt-get install -y git default-jre && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y git && \
+    rm -rf /var/lib/apt/lists/*
 
-# Install Python dependencies from requirements.txt
-# Ensure requirements.txt is copied before installing to leverage Docker cache
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Download the spaCy English language model
-# This is crucial for resolving the "[E050] Can't find model 'en_core_web_sm'" error
+
 RUN python -m spacy download en_core_web_sm
 
-# Setup Hugging Face cache directory and permissions
-# This directory will also be used by language-tool-python for its main downloads.
+
 ENV HF_HOME=/cache
 RUN mkdir -p /cache && chmod -R 777 /cache
 
-# ... other Dockerfile content ...
-ENV GRAMMAFREE_API_KEY="admin" 
 
-# Explicitly create and set permissions for /.cache
-# This is to address PermissionError: [Errno 13] Permission denied: '/.cache'
-# which language-tool-python might be trying to write to.
 RUN mkdir -p /.cache && chmod -R 777 /.cache
 
-# Set environment variable for language-tool-python download directory
-# This redirects LanguageTool's primary downloads to the shared /cache directory.
-ENV LANGUAGE_TOOL_DOWNLOAD_DIR=/cache
 
-# Copy the entire application code into the container
-# This copies your 'app' directory, including main.py, routers, models, etc.
 COPY app ./app
 
-# Command to run the FastAPI application using Uvicorn
-# Binds the app to all network interfaces (0.0.0.0) on port 7860
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Expose the port your FastAPI application will run on
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/core/app.py

@@ -0,0 +1,31 @@
+from fastapi import FastAPI
+from fastapi.middleware.gzip import GZipMiddleware
+from app.routers import (
+    grammar,
+    tone,
+    voice,
+    inclusive_language,
+    readability,
+    paraphrase,
+    translate,
+    rewrite,
+)
+
+def create_app() -> FastAPI:
+    app = FastAPI()
+    app.add_middleware(GZipMiddleware, minimum_size=500)
+    
+    app.include_router(grammar.router)
+    app.include_router(tone.router)
+    app.include_router(voice.router)
+    app.include_router(inclusive_language.router)
+    app.include_router(readability.router)
+    app.include_router(paraphrase.router)
+    app.include_router(translate.router)
+    app.include_router(rewrite.router)
+
+    @app.get("/")
+    def root():
+        return {"message": "Welcome to Grammafree API"}
+
+    return app

app/core/config.py

@@ -0,0 +1,9 @@
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    inclusive_rules_dir: str = "app/data/en"
+    openai_model: str = "gpt-4o"
+    openai_temperature: float = 0.7
+    openai_max_tokens: int = 512
+
+settings = Settings()

app/core/logging.py

@@ -0,0 +1,8 @@
+# core/logging.py
+import logging
+
+def configure_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s"
+    )

app/core/middleware.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+import logging
+
+limiter = Limiter(key_func=get_remote_address)
+
+def setup_middlewares(app: FastAPI):
+    @app.exception_handler(Exception)
+    async def unhandled_exception_handler(request: Request, exc: Exception):
+        logging.exception("Unhandled exception")
+        return JSONResponse(status_code=500, content={"detail": "Internal server error"})
+
+    @app.exception_handler(RateLimitExceeded)
+    async def rate_limit_exceeded_handler(request: Request, exc: RateLimitExceeded):
+        return JSONResponse(status_code=429, content={"detail": "Rate limit exceeded"})
+
+    limiter.init_app(app)
+    app.state.limiter = limiter

app/core/prompts.py

@@ -0,0 +1,30 @@
+def tone_prompt(text: str, tone: str) -> str:
+    return f"Change the tone of this sentence to {tone}: {text.strip()}"
+
+def summarize_prompt(text: str) -> str:
+    return f"Summarize the following text:\n{text.strip()}"
+
+def clarity_prompt(text: str) -> str:
+    return f"Improve the clarity of the following sentence:\n{text.strip()}"
+
+def conciseness_prompt(text: str) -> str:
+    return f"Make the following sentence more concise:\n{text.strip()}"
+
+def rewrite_prompt(text: str, instruction: str) -> str:
+    return f"{instruction.strip()}\n{text.strip()}"
+
+def vocabulary_prompt(text: str) -> str:
+    return (
+        "You are an expert vocabulary enhancer. Rewrite the following text "
+        "by replacing common and simple words with more sophisticated, "
+        "precise, and contextually appropriate synonyms. Do not change "
+        "the original meaning. Maintain the tone.\n" + text.strip()
+    )
+
+def concise_prompt(text: str) -> str:
+    return (
+        "You are an expert editor specializing in conciseness. "
+        "Rewrite the following text to be more concise and to the point, "
+        "removing any verbose phrases, redundant words, or unnecessary clauses. "
+        "Maintain the original meaning and professional tone.\n" + text.strip()
+    )

app/core/security.py

@@ -1,25 +1,11 @@
-from fastapi import Header, HTTPException
 import os
+from fastapi import Header, HTTPException, status, Depends
 
-# Define a simple API key for authentication.
-# In a production environment, this should be a more robust and securely managed key.
-# Load API_KEY from an environment variable for security.
-# Fallback to a default for local development if not set, but warn about it.
-API_KEY = os.getenv("GRAMMAFREE_API_KEY", "12345") # Use a strong default for production!
+API_KEY = os.getenv("GRAMMAFREE_API_KEY", "12345")
 
-if API_KEY == "12345":
-    print("WARNING: Using default API_KEY. Set GRAMMAFREE_API_KEY environment variable in production!")
-
-def verify_api_key(x_api_key: str = Header(...)):
-    """
-    Dependency function to verify the API key provided in the request headers.
-
-    Args:
-        x_api_key (str): The API key expected in the 'X-API-Key' header.
-
-    Raises:
-        HTTPException: If the provided API key does not match the expected API_KEY.
-    """
-    if x_api_key != API_KEY:
-        # Raise an HTTPException with 401 Unauthorized status if the key is invalid.
-        raise HTTPException(status_code=401, detail="Unauthorized")
+def verify_api_key(x_api_key: str = Header(...)) -> None:
+    if not x_api_key or x_api_key != API_KEY:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API key"
+        )

app/data/en/ablist.yml

@@ -0,0 +1,697 @@
+- type: basic
+  note: Refer to the person, rather than the disability, first.
+  considerate: person with learning disabilities
+  inconsiderate: learning disabled
+- type: basic
+  note: Refer to the person, rather than the disability, first.
+  considerate:
+    - turned off
+    - has a disability
+    - person with a disability
+    - people with disabilities
+  inconsiderate:
+    - disabled
+    - invalid
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Assumes/implies that a person with a disability is deficient or inferior to others. When possible, specify the functional ability or its restriction.
+  considerate:
+    - has a disability
+    - person with a disability
+    - people with disabilities
+  inconsiderate:
+    - birth defect
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Assumes that a person with a disability has a reduced quality of life.
+  considerate:
+    - has a disability
+    - person with a disability
+    - people with disabilities
+  inconsiderate:
+    - suffers from disabilities
+    - suffering from disabilities
+    - suffering from a disability
+    - afflicted with disabilities
+    - afflicted with a disability
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Refer to the person, rather than the disability, first.
+  considerate:
+    - people with intellectual disabilities
+  inconsiderate:
+    - intellectually disabled people
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Assumes that a person with an intellectual disability has a reduced quality of life.
+  considerate:
+    - person with an intellectual disability
+  inconsiderate:
+    - intellectually disabled
+    - has intellectual issues
+    - suffers from intellectual disabilities
+    - suffering from intellectual disabilities
+    - suffering from an intellectual disability
+    - afflicted with intellectual disabilities
+    - afflicted with a intellectual disability
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Describe the behavior or illness without derogatory words.
+  considerate:
+    - rude
+    - malicious
+    - mean
+    - disgusting
+    - incredible
+    - vile
+    - person with symptoms of mental illness
+    - person with mental illness
+    - person with symptoms of a mental disorder
+    - person with a mental disorder
+  inconsiderate:
+    - batshit
+    - psycho
+    - crazy
+    - delirious
+    - insane
+    - insanity
+    - loony
+    - lunacy
+    - lunatic
+    - mentally ill
+    - psychopathology
+    - mental defective
+    - moron
+    - moronic
+    - nuts
+    - mental case
+    - mental
+- type: basic
+  note: Describe the behavior or illness without derogatory words.
+  considerate:
+    - incredibly
+  inconsiderate:
+    - insanely
+- type: basic
+  note: When describing a mathematical or programmatic value, using the word “sane” needlessly invokes the topic of mental health.  Consider using a domain-specific or neutral term instead.
+  considerate:
+    - correct
+    - adequate
+    - sufficient
+    - consistent
+    - valid
+    - coherent
+    - sensible
+    - reasonable
+  inconsiderate: sane
+- type: basic
+  note: When describing a mathematical or programmatic value, using the phrase “sanity check” needlessly invokes the topic of mental health.  Consider using simply “check”, or a domain-specific or neutral term, instead.
+  considerate:
+    - check
+    - assertion
+    - validation
+    - smoke test
+  inconsiderate: sanity check
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Only use terms describing mental illness when referring to a professionally diagnosed medical condition.
+  considerate:
+    - fluctuating
+    - person with bipolar disorder
+  inconsiderate:
+    - bipolar
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Only use terms describing mental illness when referring to a professionally diagnosed medical condition.
+  considerate:
+    - person with schizophrenia
+  inconsiderate:
+    - schizophrenic
+    - schizo
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Assumes a person with schizophrenia experiences a reduced quality of life.
+  considerate:
+    - person with schizophrenia
+  inconsiderate:
+    - suffers from schizophrenia
+    - suffering from schizophrenia
+    - afflicted with schizophrenia
+    - manic
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate: accessible parking
+  inconsiderate: handicapped parking
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Refer to the person, rather than the disability, first.
+  considerate:
+    - person with a handicap
+    - accessible
+  inconsiderate: handicapped
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Refer to the person, rather than the condition, first.
+  considerate: person with an amputation
+  inconsiderate: amputee
+- type: basic
+  note: Refer to the specific disability.
+  considerate: person with a limp
+  inconsiderate:
+    - cripple
+    - crippled
+    - gimp
+- type: basic
+  considerate: person with Down Syndrome
+  inconsiderate: mongoloid
+- type: basic
+  note: Refer to the person, rather than the condition, first.
+  considerate: individual who has had a stroke
+  inconsiderate:
+    - stroke victim
+    - suffering from a stroke
+    - victim of a stroke
+- type: basic
+  considerate: person who has multiple sclerosis
+  inconsiderate:
+    - suffers from multiple sclerosis
+    - suffering from multiple sclerosis
+    - victim of multiple sclerosis
+    - multiple sclerosis victim
+    - afflicted with multiple sclerosis
+- type: basic
+  source: https://ncdj.org/style-guide
+  note: Refer to a person's condition as a state, not as an affliction.
+  considerate: person who has muscular dystrophy
+  inconsiderate:
+    - suffers from muscular dystrophy
+    - afflicted with muscular dystrophy
+    - suffers from MD
+    - afflicted with MD
+- type: basic
+  considerate: with family support needs
+  inconsiderate: family burden
+- type: basic
+  considerate:
+    - psychiatric hospital
+    - mental health hospital
+  inconsiderate:
+    - asylum
+- type: basic
+  considerate:
+    - chaos
+    - hectic
+    - pandemonium
+  inconsiderate:
+    - bedlam
+    - madhouse
+    - loony bin
+- type: basic
+  source: https://media.specialolympics.org/soi/files/press-kit/2014_FactSheet_Final.pdf
+  considerate:
+    - Down Syndrome
+  inconsiderate:
+    - downs syndrome
+- type: basic
+  considerate:
+    - silly
+    - dullard
+    - person with Down Syndrome
+    - person with developmental disabilities
+    - delay
+    - hold back
+  inconsiderate:
+    - retard
+    - retarded
+    - short bus
+- type: basic
+  considerate:
+    - sillies
+    - dullards
+    - people with developmental disabilities
+    - people with Down’s Syndrome
+    - delays
+    - holds back
+  inconsiderate: retards
+- type: basic
+  note: Only use terms describing mental illness when referring to a professionally diagnosed medical condition.
+  considerate:
+    - person with a psychotic condition
+    - person with psychosis
+  inconsiderate:
+    - psychotic
+    - suffers from psychosis
+    - suffering from psychosis
+    - afflicted with psychosis
+    - victim of psychosis
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - boring
+    - dull
+  inconsiderate: lame
+- type: basic
+  considerate:
+    - person with AIDS
+  inconsiderate:
+    - suffering from aids
+    - suffer from aids
+    - suffers from aids
+    - afflicted with aids
+    - victim of aids
+    - aids victim
+- type: basic
+  considerate:
+    - uses a wheelchair
+  inconsiderate:
+    - confined to a wheelchair
+    - bound to a wheelchair
+    - restricted to a wheelchair
+    - wheelchair bound
+- type: basic
+  source: https://media.specialolympics.org/soi/files/press-kit/2014_FactSheet_Final.pdf
+  note: When possible, use the exact discipline of sport.
+  considerate:
+    - athletes
+    - Special Olympics athletes
+  inconsiderate:
+    - special olympians
+    - special olympic athletes
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Can imply that people with disabilities lack the ability to use their bodies well. Sometimes `typical` can be used.
+  considerate:
+    - non-disabled
+  inconsiderate:
+    - ablebodied
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Addiction is a neurobiological disease.
+  considerate:
+    - person with a drug addiction
+    - person recovering from a drug addiction
+  inconsiderate:
+    - addict
+    - junkie
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Addiction is a neurobiological disease.
+  considerate:
+    - people with a drug addiction
+    - people recovering from a drug addiction
+  inconsiderate:
+    - addicts
+    - junkies
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Alcoholism is a neurobiological disease.
+  considerate:
+    - someone with an alcohol problem
+  inconsiderate:
+    - alcoholic
+    - alcohol abuser
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - deaf
+  inconsiderate:
+    - deaf and dumb
+    - deafmute
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with dementia
+  inconsiderate:
+    - demented
+    - senile
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - sad
+    - blue
+    - bummed out
+    - person with seasonal affective disorder
+    - person with psychotic depression
+    - person with postpartum depression
+  inconsiderate:
+    - depressed
+- type: basic
+  source:
+    - https://ncdj.org/style-guide/
+    - https://www.lpaonline.org/faq-#Midget
+  considerate:
+    - person with dwarfism
+    - little person
+    - little people
+    - LP
+    - person of short stature
+  inconsiderate:
+    - vertically challenged
+    - midget
+    - small person
+    - dwarf
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with dyslexia
+  inconsiderate:
+    - dyslexic
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with epilepsy
+  inconsiderate:
+    - epileptic
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: When possible, ask the person what they prefer.
+  considerate:
+    - hard of hearing
+    - partially deaf
+    - partial hearing loss
+    - deaf
+  inconsiderate:
+    - hearing impaired
+    - hearing impairment
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - polio
+    - person who had polio
+  inconsiderate:
+    - infantile paralysis
+    - suffers from polio
+    - suffering from polio
+    - suffering from a polio
+    - afflicted with polio
+    - afflicted with a polio
+    - victim of polio
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - sustain an injury
+    - receive an injury
+  inconsiderate:
+    - suffer from an injury
+    - suffers from an injury
+    - suffering from an injury
+    - afflicted with an injury
+    - victim of an injury
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - sustain injuries
+    - receive injuries
+  inconsiderate:
+    - suffer from injuries
+    - suffers from injuries
+    - suffering from injuries
+    - afflicted with injuries
+    - victim of injuries
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with paraplegia
+  inconsiderate:
+    - paraplegic
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with quadriplegia
+  inconsiderate:
+    - quadriplegic
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with cerebral palsy
+    - twitch
+    - flinch
+    - hectic
+  inconsiderate:
+    - spaz
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person with cerebral palsy
+    - twitch
+    - flinch
+  inconsiderate:
+    - spastic
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - stuttering
+    - disfluency of speech
+  inconsiderate:
+    - stammering
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - person who stutters
+  inconsiderate:
+    - stutterer
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - Tourette syndrome
+  inconsiderate:
+    - tourettes syndrome
+    - tourettes disorder
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - treatment center
+  inconsiderate:
+    - rehab center
+    - detox center
+- type: basic
+  source: https://ncdj.org/style-guide/
+  considerate:
+    - treatment
+  inconsiderate:
+    - rehab
+    - detox
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Only use terms describing mental illness when referring to a professionally diagnosed medical condition.
+  considerate:
+    - person with a personality disorder
+    - person with psychopathic personality
+  inconsiderate:
+    - sociopath
+- type: basic
+  source: https://ncdj.org/style-guide/
+  note: Only use terms describing mental illness when referring to a professionally diagnosed medical condition.
+  considerate:
+    - people with psychopathic personalities
+    - people with a personality disorder
+  inconsiderate:
+    - sociopaths
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  note: Dumb here is used in 2 different contexts , the inability to talk or as a curse word.
+  considerate:
+    - foolish
+    - ludicrous
+    - speechless
+    - silent
+  inconsiderate:
+    - dumb
+- type: basic
+  source: https://web.archive.org/web/20181025174508/http://www.mmonjejr.com:80/2014/02/deconstructing-stupid.html
+  considerate:
+    - foolish
+    - ludicrous
+    - unintelligent
+  inconsiderate:
+    - simpleton
+    - stupid
+    - wacko
+    - whacko
+    - low iq
+- type: basic
+  considerate:
+    - fit of terror
+    - scare
+  inconsiderate:
+    - panic attack
+- type: basic
+  considerate:
+    - thin
+    - slim
+  inconsiderate:
+    - anorexic
+    - bony
+- type: basic
+  source: https://english.stackexchange.com/questions/247550/
+  note: Only use terms describing mental illness when referring to a professionally diagnosed medical condition.
+  considerate:
+    - has an anxiety disorder
+    - obsessive
+    - pedantic
+    - niggly
+    - picky
+  inconsiderate:
+    - neurotic
+    - ocd
+    - o.c.d
+    - o.c.d.
+- type: basic
+  considerate:
+    - restlessness
+    - sleeplessness
+  inconsiderate:
+    - insomnia
+- type: basic
+  considerate:
+    - person who has insomnia
+  inconsiderate:
+    - insomniac
+- type: basic
+  considerate:
+    - people who have insomnia
+  inconsiderate:
+    - insomniacs
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - empty
+    - sterile
+    - infertile
+  inconsiderate:
+    - barren
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - careless
+    - heartless
+    - indifferent
+    - insensitive
+  inconsiderate:
+    - blind to
+    - blind eye to
+    - blinded by
+    - deaf to
+    - deaf ear to
+    - deafened by
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - creep
+    - fool
+  inconsiderate:
+    - cretin
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - absurd
+    - foolish
+  inconsiderate:
+    - daft
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - foolish
+    - ludicrous
+    - silly
+  inconsiderate:
+    - feebleminded
+    - feeble minded
+    - idiot
+    - imbecile
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  note: Sometimes it's cleft lip or palate, not both. Specify when possible.
+  considerate:
+    - person with a cleft-lip and palate
+  inconsiderate:
+    - harelipped
+    - cleftlipped
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - cleft-lip and palate
+  inconsiderate:
+    - harelip
+    - hare lip
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - fanatic
+    - zealot
+    - enthusiast
+  inconsiderate:
+    - maniac
+- type: basic
+  considerate:
+    - person with prominent teeth
+    - prominent teeth
+  inconsiderate:
+    - bucktoothed
+    - buckteeth
+- type: basic
+  source:
+    - http://cdrnys.org/blog/disability-dialogue/the-disability-dialogue-4-disability-euphemisms-that-need-to-bite-the-dust/
+    - https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  note: Euphemisms for disabilities can be infantilizing.
+  considerate:
+    - has a disability
+    - person with a disability
+    - people with disabilities
+  inconsiderate:
+    - challenged
+    - diffability
+    - differently abled
+    - handicapable
+    - special
+    - special needs
+    - specially abled
+- type: basic
+  source: https://www.autistichoya.com/p/ableist-words-and-terms-to-avoid.html
+  considerate:
+    - disagreeable
+    - uneducated
+    - ignorant
+    - naive
+    - inconsiderate
+  inconsiderate:
+    - fucktard
+    - libtard
+    - contard
+- type: basic
+  considerate:
+    - disorganized
+    - distracted
+    - energetic
+    - hyperactive
+    - impetuous
+    - impulsive
+    - inattentive
+    - restless
+    - unfocused
+  inconsiderate:
+    # Upper case to only match `ADD`, not `add`.
+    - ADD
+    - adhd
+    - a.d.d.
+    - a.d.h.d.
+- type: basic
+  note: Dummy can refer to the inability to talk or be used as a derogatory word meaning stupid. In computer programming it is used where a value or behavior is unimportant. There are better alternatives for other use cases also.
+  considerate:
+    - test double
+    - placeholder
+    - fake
+    - stub
+  inconsiderate:
+    - dummyvariable
+    - dummyvalue
+    - dummyobject
+    - dummy
+- type: basic
+  note: Binge might be insensitive towards folks with eating or drinking disorders
+  source: https://github.com/retextjs/retext-equality/issues/110
+  considerate:
+    - enthusiastic
+    - spree
+  inconsiderate:
+    - binge

app/data/en/condescending.yml

@@ -0,0 +1,50 @@
+# List of words to avoid, specifically in education writing.
+# From: https://css-tricks.com/words-avoid-educational-writing/
+# The terms `however` and `so` are not included as they’re only an offense if at
+# the start of a sentence according to CSS Tricks.
+# If you want messages for those, use `retext-intensify`.
+- type: basic
+  inconsiderate:
+    - obvious
+    - obviously
+  note: Not everything is as obvious as you might think. And if it isn’t obvious to the reader, it can hurt.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate: just
+  note: Not everything is as easy as you might think. And if it isn’t easy for the reader, it can hurt.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate: basically
+  note: It’s probably not that basic. If you’re going to explain a confusing previous sentence with a clearer next sentence, why not drop the former and only use the latter?
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate:
+    - simple
+    - simply
+  note: It’s probably not that simple. Even if it is, you probably don’t need to specifically say it.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate:
+    - easy
+    - easily
+  note: It’s probably not that easy. Even if it is, you probably don’t need to specifically say it.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate: of course
+  note: If it’s self-evident then maybe you don’t need to describe it. If it isn’t, don’t say it.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate: clearly
+  note: If it’s self-evident then maybe you don’t need to describe it. If it isn’t, don’t say it.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate: everyone knows
+  note: If it’s self-evident then maybe you don’t need to describe it. If it isn’t, don’t say it.
+  source: https://css-tricks.com/words-avoid-educational-writing/
+- type: basic
+  inconsiderate:
+    - straight forward
+    - straightforward
+    - straight forwardly
+    - straightforwardly
+  note: It’s probably not that straight forward. Even if it is, you probably don’t need to specifically say it.

app/data/en/gender.yml

@@ -0,0 +1,1808 @@
+- type: or
+  condition: when referring to a person
+  considerate:
+    - their
+    - theirs
+    - them
+  inconsiderate:
+    her: female
+    hers: female
+    him: male
+    his: male
+- type: or
+  apostrophe: true
+  considerate:
+    - they
+    - it
+  inconsiderate:
+    she: female
+    he: male
+    she'd: female
+    he'd: male
+    she'll: female
+    he'll: male
+    she's: female
+    he's: male
+- type: or
+  considerate:
+    - themselves
+    - theirself
+    - self
+  inconsiderate:
+    herself: female
+    himself: male
+- type: or
+  condition: when referring to a person
+  considerate:
+    - kid
+    - child
+    - youth
+  inconsiderate:
+    girl: female
+    boy: male
+- type: or
+  considerate:
+    - people
+    - persons
+    - folks
+  inconsiderate:
+    women: female
+    girls: female
+    gals: female
+    ladies: female
+    man: male
+    boys: male
+    men: male
+    guys: male
+    dudes: male
+    gents: male
+    gentlemen: male
+- type: or
+  considerate:
+    - person
+    - friend
+    - pal
+    - folk
+    - individual
+  inconsiderate:
+    woman: female
+    gal: female
+    lady: female
+    babe: female
+    bimbo: female
+    chick: female
+    guy: male
+    lad: male
+    fellow: male
+    dude: male
+    bro: male
+    gentleman: male
+- type: or
+  considerate:
+    - native land
+    - homeland
+  inconsiderate:
+    motherland: female
+    fatherland: male
+- type: or
+  considerate:
+    - native tongue
+    - native language
+  inconsiderate:
+    mother tongue: female
+    father tongue: male
+- type: or
+  considerate:
+    - first-year students
+    - freshers
+  inconsiderate:
+    freshwomen: female
+    freshmen: male
+- type: or
+  considerate:
+    - garbage collector
+    - waste collector
+    - trash collector
+  inconsiderate:
+    garbagewoman: female
+    garbageman: male
+- type: or
+  considerate:
+    - garbage collectors
+    - waste collectors
+    - trash collectors
+  inconsiderate:
+    garbagewomen: female
+    garbagemen: male
+- type: or
+  considerate:
+    - chair
+    - head
+    - chairperson
+    - coordinator
+    - committee head
+    - moderator
+    - presiding officer
+  inconsiderate:
+    chairwoman: female
+    chairman: male
+- type: or
+  considerate:
+    - committee member
+  inconsiderate:
+    committee woman: female
+    committee man: male
+- type: or
+  considerate:
+    - cowhand
+  inconsiderate:
+    cowgirl: female
+    cowboy: male
+- type: or
+  considerate:
+    - cowhands
+  inconsiderate:
+    cowgirls: female
+    cowboys: male
+- type: or
+  considerate:
+    - cattle rancher
+  inconsiderate:
+    cattlewoman: female
+    cattleman: male
+- type: or
+  considerate:
+    - cattle ranchers
+  inconsiderate:
+    cattlewomen: female
+    cattlemen: male
+- type: or
+  considerate:
+    - chairs
+    - chairpersons
+    - coordinators
+  inconsiderate:
+    chairwomen: female
+    chairmen: male
+- type: or
+  considerate:
+    - mail carrier
+    - letter carrier
+    - postal worker
+  inconsiderate:
+    postwoman: female
+    mailwoman: female
+    postman: male
+    mailman: male
+- type: or
+  considerate:
+    - mail carriers
+    - letter carriers
+    - postal workers
+  inconsiderate:
+    postwomen: female
+    mailwomen: female
+    postmen: male
+    mailmen: male
+- type: or
+  considerate:
+    - officer
+    - police officer
+  inconsiderate:
+    policewoman: female
+    policeman: male
+    chick cop: female
+- type: or
+  considerate:
+    - officers
+    - police officers
+  inconsiderate:
+    policewomen: female
+    policemen: male
+- type: or
+  considerate:
+    - flight attendant
+  inconsiderate:
+    stewardess: female
+    steward: male
+- type: or
+  considerate:
+    - flight attendants
+  inconsiderate:
+    stewardesses: female
+    stewards: male
+- type: or
+  considerate:
+    - member of congress
+    - congress person
+    - legislator
+    - representative
+  inconsiderate:
+    congresswoman: female
+    congressman: male
+- type: or
+  considerate:
+    - members of congress
+    - congress persons
+    - legislators
+    - representatives
+  inconsiderate:
+    congresswomen: female
+    congressmen: male
+- type: or
+  considerate:
+    - fire fighter
+    - fire officer
+  inconsiderate:
+    firewoman: female
+    fireman: male
+- type: or
+  considerate:
+    - fire fighters
+  inconsiderate:
+    firewomen: female
+    firemen: male
+- type: or
+  considerate:
+    - fisher
+    - crew member
+    - fisherfolk
+    - angler
+  inconsiderate:
+    fisherwoman: female
+    fisherman: male
+- type: or
+  considerate:
+    - fishers
+  inconsiderate:
+    fisherwomen: female
+    fishermen: male
+- type: or
+  considerate:
+    - kinship
+    - community
+  inconsiderate:
+    sisterhood: female
+    brotherhood: male
+- type: or
+  considerate:
+    - common person
+    - average person
+  inconsiderate:
+    common girl: female
+    common man: male
+- type: or
+  considerate:
+    - business executive
+    - entrepreneur
+    - business person
+    - professional
+  inconsiderate:
+    businesswoman: female
+    salarywoman: female
+    businessman: male
+    salaryman: male
+- type: or
+  considerate:
+    - business executives
+    - entrepreneurs
+  inconsiderate:
+    businesswomen: female
+    salarywomen: female
+    career girl: female
+    career woman: female
+    businessmen: male
+    salarymen: male
+- type: or
+  considerate:
+    - cleaner
+  inconsiderate:
+    cleaning lady: female
+    cleaning girl: female
+    cleaning woman: female
+    janitress: female
+    cleaning man: male
+    cleaning boy: male
+    janitor: male
+- type: or
+  considerate:
+    - cleaners
+    - housekeeping
+  inconsiderate:
+    cleaning ladies: female
+    cleaning girls: female
+    janitresses: female
+    cleaning men: male
+    janitors: male
+- type: or
+  considerate:
+    - courier
+    - messenger
+  inconsiderate:
+    delivery girl: female
+    delivery boy: male
+- type: or
+  considerate:
+    - supervisor
+    - shift boss
+  inconsiderate:
+    forewoman: female
+    foreman: male
+- type: or
+  considerate:
+    - lead
+    - front
+    - figurehead
+  inconsiderate:
+    'frontwoman, front woman': female
+    'frontman, front man': male
+- type: or
+  considerate:
+    - figureheads
+  inconsiderate:
+    'front women, frontwomen': female
+    'front men, frontmen': male
+- type: or
+  considerate:
+    - supervisors
+    - shift bosses
+  inconsiderate:
+    forewomen: female
+    foremen: male
+- type: or
+  considerate:
+    - insurance agent
+  inconsiderate:
+    insurance woman: female
+    insurance man: male
+- type: or
+  considerate:
+    - insurance agents
+  inconsiderate:
+    insurance women: female
+    insurance men: male
+- type: or
+  considerate:
+    - proprietor
+    - building manager
+  inconsiderate:
+    landlady: female
+    landlord: male
+- type: or
+  considerate:
+    - proprietors
+    - building managers
+  inconsiderate:
+    landladies: female
+    landlords: male
+- type: or
+  considerate:
+    - graduate
+  inconsiderate:
+    alumna: female
+    alumnus: male
+- type: or
+  considerate:
+    - graduates
+  inconsiderate:
+    alumnae: female
+    alumni: male
+- type: or
+  considerate:
+    - anchor
+    - journalist
+  inconsiderate:
+    newswoman: female
+    newspaperwoman: female
+    anchorwoman: female
+    newsman: male
+    newspaperman: male
+    anchorman: male
+- type: or
+  considerate:
+    - anchors
+    - journalists
+  inconsiderate:
+    newswomen: female
+    newspaperwomen: female
+    anchorwomen: female
+    newsmen: male
+    newspapermen: male
+    anchormen: male
+- type: or
+  considerate:
+    - repairer
+    - technician
+  inconsiderate:
+    repairwoman: female
+    repairman: male
+- type: or
+  considerate:
+    - technicians
+  inconsiderate:
+    repairwomen: female
+    repairmen: male
+- type: or
+  considerate:
+    - salesperson
+    - sales clerk
+    - sales rep
+    - sales agent
+    - sales attendant
+    - seller
+    - shop assistant
+  inconsiderate:
+    saleswoman: female
+    sales woman: female
+    saleslady: female
+    salesman: male
+    sales man: male
+- type: or
+  considerate:
+    - sales clerks
+    - sales reps
+    - sales agents
+    - sellers
+  inconsiderate:
+    saleswomen: female
+    sales women: female
+    salesladies: female
+    salesmen: male
+    sales men: male
+- type: or
+  considerate:
+    - soldier
+    - service representative
+  inconsiderate:
+    servicewoman: female
+    serviceman: male
+- type: or
+  considerate:
+    - soldiers
+    - service representatives
+  inconsiderate:
+    servicewomen: female
+    servicemen: male
+- type: or
+  considerate:
+    - server
+  inconsiderate:
+    waitress: female
+    waiter: male
+- type: or
+  considerate:
+    - servers
+  inconsiderate:
+    waitresses: female
+    waiters: male
+- type: or
+  considerate:
+    - worker
+    - wage earner
+    - taxpayer
+  inconsiderate:
+    workwoman: female
+    working woman: female
+    workman: male
+    working man: male
+- type: or
+  considerate:
+    - workers
+  inconsiderate:
+    workwomen: female
+    workmen: male
+- type: or
+  considerate:
+    - performer
+    - star
+    - artist
+    - entertainer
+  inconsiderate:
+    actress: female
+    actor: male
+- type: or
+  considerate:
+    - performers
+    - stars
+    - artists
+    - entertainers
+  inconsiderate:
+    actresses: female
+    actors: male
+- type: or
+  considerate:
+    - pilot
+    - aviator
+    - airstaff
+  inconsiderate:
+    aircrewwoman: female
+    aircrew woman: female
+    aircrewman: male
+    airman: male
+- type: or
+  considerate:
+    - pilots
+    - aviators
+    - airstaff
+  inconsiderate:
+    aircrewwomen: female
+    aircrew women: female
+    aircrewmen: male
+    airmen: male
+- type: or
+  considerate:
+    - cabinet member
+  inconsiderate:
+    alderwoman: female
+    alderman: male
+- type: or
+  considerate:
+    - cabinet
+    - cabinet members
+    - alderperson
+  inconsiderate:
+    alderwomen: female
+    aldermen: male
+- type: or
+  considerate:
+    - assembly person
+    - assembly worker
+  inconsiderate:
+    assemblywoman: female
+    assemblyman: male
+- type: or
+  considerate:
+    - relative
+  inconsiderate:
+    kinswoman: female
+    aunt: female
+    kinsman: male
+    uncle: male
+- type: or
+  considerate:
+    - relatives
+  inconsiderate:
+    kinswomen: female
+    aunts: female
+    kinsmen: male
+    uncles: male
+- type: or
+  considerate:
+    - boogeymonster
+  inconsiderate:
+    boogeywoman: female
+    boogeyman: male
+- type: or
+  considerate:
+    - boogeymonster
+  inconsiderate:
+    boogiewoman: female
+    boogieman: male
+- type: or
+  considerate:
+    - bogeymonster
+  inconsiderate:
+    bogeywoman: female
+    bogeyman: male
+- type: or
+  considerate:
+    - bogeymonster
+  inconsiderate:
+    bogiewoman: female
+    bogieman: male
+- type: or
+  considerate:
+    - boogeymonsters
+  inconsiderate:
+    boogiewomen: female
+    boogiemen: male
+- type: or
+  considerate:
+    - bogeymonsters
+  inconsiderate:
+    bogiewomen: female
+    bogiemen: male
+- type: or
+  considerate:
+    - bonder
+  inconsiderate:
+    bondswoman: female
+    bondsman: male
+- type: or
+  considerate:
+    - bonders
+  inconsiderate:
+    bondswomen: female
+    bondsmen: male
+- type: or
+  source: https://www.bustle.com/articles/108321-6-reasons-to-refer-to-your-significant-other-as-your-partner
+  considerate:
+    - partner
+    - significant other
+    - spouse
+  inconsiderate:
+    wife: female
+    husband: male
+- type: or
+  source: https://www.bustle.com/articles/108321-6-reasons-to-refer-to-your-significant-other-as-your-partner
+  considerate:
+    - partners
+    - significant others
+    - spouses
+  inconsiderate:
+    wives: female
+    husbands: male
+- type: or
+  source: https://www.bustle.com/articles/108321-6-reasons-to-refer-to-your-significant-other-as-your-partner
+  considerate:
+    - partner
+    - friend
+    - significant other
+  inconsiderate:
+    girlfriend: female
+    boyfriend: male
+- type: or
+  source: https://www.bustle.com/articles/108321-6-reasons-to-refer-to-your-significant-other-as-your-partner
+  considerate:
+    - partners
+    - friends
+    - significant others
+  inconsiderate:
+    girlfriends: female
+    boyfriends: male
+- type: or
+  considerate:
+    - childhood
+  inconsiderate:
+    girlhood: female
+    boyhood: male
+- type: or
+  considerate:
+    - childish
+  inconsiderate:
+    girly: female
+    girlish: female
+    boyish: male
+- type: or
+  considerate:
+    - journeyperson
+  inconsiderate:
+    journeywoman: female
+    journeyman: male
+- type: or
+  considerate:
+    - journeypersons
+  inconsiderate:
+    journeywomen: female
+    journeymen: male
+- type: or
+  considerate:
+    - godparent
+    - elder
+    - patron
+  inconsiderate:
+    godmother: female
+    patroness: female
+    godfather: male
+- type: or
+  considerate:
+    - grandchild
+  inconsiderate:
+    granddaughter: female
+    grandson: male
+- type: or
+  considerate:
+    - grandchildren
+  inconsiderate:
+    granddaughters: female
+    grandsons: male
+- type: or
+  considerate:
+    - ancestor
+  inconsiderate:
+    foremother: female
+    forefather: male
+- type: or
+  considerate:
+    - ancestors
+  inconsiderate:
+    foremothers: female
+    forefathers: male
+- type: or
+  considerate:
+    - grandparent
+    - ancestor
+  inconsiderate:
+    granny: female
+    grandma: female
+    grandmother: female
+    grandpappy: male
+    granddaddy: male
+    gramps: male
+    grandpa: male
+    grandfather: male
+- type: or
+  considerate:
+    - grandparents
+    - ancestors
+  inconsiderate:
+    grandmothers: female
+    grandfathers: male
+- type: or
+  considerate:
+    - spouse
+    - newlywed
+  inconsiderate:
+    bride: female
+    groom: male
+- type: or
+  considerate:
+    - sibling
+  inconsiderate:
+    sister: female
+    brother: male
+- type: or
+  considerate:
+    - siblings
+  inconsiderate:
+    sisters: female
+    brothers: male
+- type: or
+  considerate:
+    - camera operator
+    - camera person
+  inconsiderate:
+    camerawoman: female
+    cameraman: male
+- type: or
+  considerate:
+    - camera operators
+  inconsiderate:
+    camerawomen: female
+    cameramen: male
+- type: or
+  considerate:
+    - troglodyte
+    - hominidae
+  inconsiderate:
+    cavewoman: female
+    caveman: male
+- type: or
+  considerate:
+    - troglodytae
+    - troglodyti
+    - troglodytes
+    - hominids
+  inconsiderate:
+    cavewomen: female
+    cavemen: male
+- type: or
+  considerate:
+    - clergyperson
+    - clergy
+    - cleric
+  inconsiderate:
+    clergywoman: female
+    clergyman: male
+- type: or
+  considerate:
+    - clergies
+    - clerics
+  inconsiderate:
+    clergywomen: female
+    clergymen: male
+- type: or
+  considerate:
+    - council member
+  inconsiderate:
+    councilwoman: female
+    councilman: male
+- type: or
+  considerate:
+    - council members
+  inconsiderate:
+    councilwomen: female
+    councilmen: male
+- type: or
+  considerate:
+    - country person
+  inconsiderate:
+    countrywoman: female
+    countryman: male
+- type: or
+  considerate:
+    - country folk
+  inconsiderate:
+    countrywomen: female
+    countrymen: male
+- type: or
+  considerate:
+    - artisan
+    - craftsperson
+    - skilled worker
+  inconsiderate:
+    handywoman: female
+    craftswoman: female
+    handyman: male
+    craftsman: male
+- type: or
+  considerate:
+    - presenter
+    - entertainer
+    - emcee
+  inconsiderate:
+    hostess: female
+    host: male
+- type: or
+  considerate:
+    - presenters
+    - entertainers
+    - emcees
+  inconsiderate:
+    hostesses: female
+    hosts: male
+- type: or
+  considerate:
+    - artisans
+    - craftspersons
+    - skilled workers
+  inconsiderate:
+    handywomen: female
+    craftswomen: female
+    handymen: male
+    craftsmen: male
+- type: or
+  considerate:
+    - guillotine
+  inconsiderate:
+    hangwoman: female
+    hangman: male
+- type: or
+  considerate:
+    - guillotines
+  inconsiderate:
+    hangwomen: female
+    hangmen: male
+- type: or
+  considerate:
+    - sidekick
+  inconsiderate:
+    henchwoman: female
+    henchman: male
+- type: or
+  considerate:
+    - sidekicks
+  inconsiderate:
+    henchwomen: female
+    henchmen: male
+- type: or
+  considerate:
+    - role-model
+    - mentor
+  inconsiderate:
+    heroine: female
+    hero: male
+- type: or
+  considerate:
+    - role-models
+    - mentor
+  inconsiderate:
+    heroines: female
+    heroes: male
+- type: or
+  considerate:
+    - parental
+    - warm
+    - intimate
+  inconsiderate:
+    maternal: female
+    paternal: male
+    fraternal: male
+- type: or
+  considerate:
+    - parental
+  inconsiderate:
+    maternity: female
+    paternity: male
+- type: or
+  considerate:
+    - parents
+  inconsiderate:
+    mamas: female
+    mothers: female
+    moms: female
+    mums: female
+    mommas: female
+    mommies: female
+    papas: male
+    fathers: male
+    dads: male
+    daddies: male
+- type: or
+  considerate:
+    - parent
+  inconsiderate:
+    mama: female
+    mother: female
+    mom: female
+    mum: female
+    momma: female
+    mommy: female
+    papa: male
+    father: male
+    dad: male
+    pop: male
+    daddy: male
+- type: or
+  considerate:
+    - child
+  inconsiderate:
+    daughter: female
+    son: male
+- type: or
+  considerate:
+    - children
+  inconsiderate:
+    daughters: female
+    sons: male
+- type: or
+  considerate:
+    - concierge
+  inconsiderate:
+    doorwoman: female
+    doorman: male
+- type: or
+  considerate:
+    - concierges
+  inconsiderate:
+    doorwomen: female
+    doormen: male
+- type: or
+  considerate:
+    - humanly
+    - mature
+  inconsiderate:
+    feminin: female
+    dudely: male
+    manly: male
+- type: or
+  considerate:
+    - humans
+  inconsiderate:
+    females: female
+    males: male
+- type: or
+  considerate:
+    - ruler
+  inconsiderate:
+    empress: female
+    queen: female
+    emperor: male
+    king: male
+- type: or
+  considerate:
+    - rulers
+  inconsiderate:
+    empresses: female
+    queens: female
+    emperors: male
+    kings: male
+- type: or
+  considerate:
+    - jumbo
+    - gigantic
+  inconsiderate:
+    queensize: female
+    kingsize: male
+- type: or
+  considerate:
+    - power behind the throne
+  inconsiderate:
+    queenmaker: female
+    kingmaker: male
+- type: or
+  considerate:
+    - civilian
+  inconsiderate:
+    laywoman: female
+    layman: male
+- type: or
+  considerate:
+    - civilians
+  inconsiderate:
+    laywomen: female
+    laymen: male
+- type: or
+  considerate:
+    - official
+    - owner
+    - expert
+    - superior
+    - chief
+    - ruler
+  inconsiderate:
+    dame: female
+    lord: male
+- type: or
+  considerate:
+    - officials
+    - chiefs
+    - rulers
+  inconsiderate:
+    dames: female
+    lords: male
+- type: or
+  considerate:
+    - adulthood
+    - personhood
+    - maturity
+  inconsiderate:
+    womanhood: female
+    masculinity: male
+    manhood: male
+- type: or
+  considerate:
+    - humanity
+  inconsiderate:
+    femininity: female
+    manliness: male
+- type: or
+  considerate:
+    - shooter
+  inconsiderate:
+    markswoman: female
+    marksman: male
+- type: or
+  considerate:
+    - shooters
+  inconsiderate:
+    markswomen: female
+    marksmen: male
+- type: or
+  considerate:
+    - intermediary
+    - go-between
+  inconsiderate:
+    middlewoman: female
+    middleman: male
+- type: or
+  considerate:
+    - intermediaries
+    - go-betweens
+  inconsiderate:
+    middlewomen: female
+    middlemen: male
+- type: or
+  considerate:
+    - milk person
+  inconsiderate:
+    milkwoman: female
+    milkman: male
+- type: or
+  considerate:
+    - milk people
+  inconsiderate:
+    milkwomen: female
+    milkmen: male
+- type: or
+  considerate:
+    - nibling
+    - sibling’s child
+  inconsiderate:
+    niece: female
+    nephew: male
+- type: or
+  considerate:
+    - niblings
+    - sibling’s children
+  inconsiderate:
+    nieces: female
+    nephews: male
+- type: or
+  considerate:
+    - noble
+  inconsiderate:
+    noblewoman: female
+    nobleman: male
+- type: or
+  considerate:
+    - nobles
+  inconsiderate:
+    noblewomen: female
+    noblemen: male
+- type: or
+  considerate:
+    - notary
+    - consumer advocate
+    - trouble shooter
+    - omsbudperson
+    - mediator
+  inconsiderate:
+    ombudswoman: female
+    ombudsman: male
+- type: or
+  considerate:
+    - notaries
+    - omsbudpersons
+    - omsbudpeople
+    - mediators
+  inconsiderate:
+    ombudswomen: female
+    ombudsmen: male
+- type: or
+  considerate:
+    - heir
+  inconsiderate:
+    princess: female
+    prince: male
+- type: or
+  considerate:
+    - heirs
+  inconsiderate:
+    princesses: female
+    princes: male
+- type: or
+  considerate:
+    - fairy
+  inconsiderate:
+    sandwoman: female
+    sandman: male
+- type: or
+  considerate:
+    - fairies
+  inconsiderate:
+    sandwomen: female
+    sandmen: male
+- type: or
+  considerate:
+    - promoter
+  inconsiderate:
+    showwoman: female
+    showman: male
+- type: or
+  considerate:
+    - promoters
+  inconsiderate:
+    showwomen: female
+    show women: female
+    showmen: male
+- type: or
+  considerate:
+    - astronaut
+  inconsiderate:
+    spacewoman: female
+    spaceman: male
+- type: or
+  considerate:
+    - astronauts
+  inconsiderate:
+    spacewomen: female
+    spacemen: male
+- type: or
+  considerate:
+    - speaker
+    - spokesperson
+    - representative
+  inconsiderate:
+    spokeswoman: female
+    spokesman: male
+- type: or
+  considerate:
+    - speakers
+    - spokespersons
+  inconsiderate:
+    spokeswomen: female
+    spokesmen: male
+- type: or
+  considerate:
+    - athlete
+    - sports person
+  inconsiderate:
+    sportswoman: female
+    sportsman: male
+- type: or
+  considerate:
+    - athletes
+    - sports persons
+  inconsiderate:
+    sportswomen: female
+    sportsmen: male
+- type: or
+  considerate:
+    - senator
+  inconsiderate:
+    stateswoman: female
+    statesman: male
+- type: or
+  considerate:
+    - step-sibling
+  inconsiderate:
+    stepsister: female
+    stepbrother: male
+- type: or
+  considerate:
+    - step-siblings
+  inconsiderate:
+    stepsisters: female
+    stepbrothers: male
+- type: or
+  considerate:
+    - step-parent
+  inconsiderate:
+    stepmom: female
+    stepmother: female
+    stepdad: male
+    stepfather: male
+- type: or
+  considerate:
+    - step-parents
+  inconsiderate:
+    stepmothers: female
+    stepfathers: male
+- type: or
+  considerate:
+    - titan
+  inconsiderate:
+    superwoman: female
+    superman: male
+- type: or
+  considerate:
+    - titans
+  inconsiderate:
+    superwomen: female
+    supermen: male
+- type: or
+  considerate:
+    - inhumane
+  inconsiderate:
+    unwomanly: female
+    unwomenly: female
+    unmanly: male
+    unmenly: male
+- type: or
+  considerate:
+    - watcher
+  inconsiderate:
+    watchwoman: female
+    watchman: male
+- type: or
+  considerate:
+    - watchers
+  inconsiderate:
+    watchwomen: female
+    watchmen: male
+- type: or
+  considerate:
+    - weather forecaster
+    - meteorologist
+  inconsiderate:
+    weatherwoman: female
+    weatherman: male
+- type: or
+  considerate:
+    - weather forecasters
+    - meteorologists
+  inconsiderate:
+    weatherwomen: female
+    weathermen: male
+- type: or
+  considerate:
+    - bereaved
+  inconsiderate:
+    widow: female
+    widows: female
+    widower: male
+    widowers: male
+- type: or
+  considerate:
+    - own person
+  inconsiderate:
+    own woman: female
+    own man: male
+- type: basic
+  considerate:
+    - french
+    - the french
+  inconsiderate:
+    frenchmen: male
+- type: basic
+  considerate:
+    - courteous
+    - cultured
+  inconsiderate:
+    ladylike: female
+- type: basic
+  considerate:
+    - resolutely
+    - bravely
+  inconsiderate:
+    like a man: male
+- type: basic
+  considerate:
+    - birth name
+  inconsiderate:
+    maiden name: female
+- type: basic
+  considerate:
+    - first voyage
+  inconsiderate:
+    maiden voyage: female
+- type: basic
+  considerate:
+    - first flight
+  inconsiderate:
+    maiden flight: female
+- type: basic
+  considerate:
+    - strong enough
+  inconsiderate:
+    man enough: male
+- type: basic
+  considerate:
+    - upstaging
+    - competitiveness
+  inconsiderate:
+    oneupmanship: male
+- type: basic
+  considerate:
+    - ms.
+  inconsiderate:
+    miss.: female
+    mrs.: female
+- type: basic
+  considerate:
+    - manufactured
+    - artificial
+    - synthetic
+    - machine-made
+    - constructed
+  inconsiderate:
+    manmade: male
+- type: basic
+  considerate:
+    - dynamo
+  inconsiderate:
+    man of action: male
+- type: basic
+  considerate:
+    - scholar
+    - writer
+    - literary figure
+  inconsiderate:
+    man of letters: male
+- type: basic
+  considerate:
+    - sophisticate
+  inconsiderate:
+    man of the world: male
+- type: basic
+  considerate:
+    - camaraderie
+    - community
+    - organization
+  inconsiderate:
+    fellowship: male
+- type: basic
+  considerate:
+    - first-year student
+    - fresher
+  inconsiderate:
+    freshman: male
+    freshwoman: male
+- type: basic
+  considerate:
+    - quality construction
+    - expertise
+  inconsiderate:
+    workmanship: male
+- type: basic
+  considerate:
+    - homemaker
+    - homeworker
+  inconsiderate:
+    housewife: female
+- type: basic
+  considerate:
+    - homemakers
+    - homeworkers
+  inconsiderate:
+    housewives: female
+- type: basic
+  considerate:
+    - loving
+    - warm
+    - nurturing
+  inconsiderate:
+    motherly: female
+- type: basic
+  considerate:
+    - human resources
+    - workforce
+    - personnel
+    - staff
+    - labor
+    - personnel
+    - labor force
+    - staffing
+    - combat personnel
+  inconsiderate:
+    manpower: male
+- type: basic
+  considerate:
+    - emcee
+    - moderator
+    - convenor
+  inconsiderate:
+    master of ceremonies: male
+- type: basic
+  considerate:
+    - skilled
+    - authoritative
+    - commanding
+  inconsiderate:
+    masterful: male
+- type: basic
+  considerate:
+    - genius
+    - creator
+    - instigator
+    - oversee
+    - launch
+    - originate
+  inconsiderate:
+    mastermind: male
+- type: basic
+  considerate:
+    - work of genius
+    - chef d’oeuvre
+  inconsiderate:
+    masterpiece: male
+- type: basic
+  considerate:
+    - vision
+    - comprehensive plan
+  inconsiderate:
+    masterplan: male
+- type: basic
+  considerate:
+    - trump card
+    - stroke of genius
+  inconsiderate:
+    masterstroke: male
+- type: basic
+  considerate:
+    - fanatic
+    - zealot
+    - enthusiast
+  inconsiderate:
+    madman: male
+    mad man: male
+- type: basic
+  considerate:
+    - fanatics
+    - zealots
+    - enthusiasts
+  inconsiderate:
+    madmen: male
+    mad men: male
+- type: basic
+  considerate:
+    - humankind
+  inconsiderate:
+    mankind: male
+- type: basic
+  considerate:
+    - staff hour
+    - hour of work
+  inconsiderate:
+    manhour: male
+    man hour: male
+- type: basic
+  considerate:
+    - staff hours
+    - hours of work
+    - hours of labor
+    - hours
+  inconsiderate:
+    manhours: male
+    man hours: male
+- type: basic
+  note: Using gender neutral language means users will help to break up gender stereotypes.
+  considerate:
+    - staffed
+    - crewed
+    - piloted
+  inconsiderate:
+    - manned
+- type: basic
+  note: Using gender neutral language means users will help to break up gender stereotypes.
+  considerate:
+    - robotic
+    - automated
+  inconsiderate:
+    - unmanned
+- type: basic
+  considerate:
+    - whining
+    - complaining
+    - crying
+  inconsiderate:
+    - bitching
+    - moaning
+- type: basic
+  considerate:
+    - whine
+    - complain
+    - cry
+  inconsiderate:
+    - bitch
+    - moan
+- type: basic
+  considerate:
+    - tank top
+    - sleeveless undershirt
+  inconsiderate:
+    - wife beater
+    - wifebeater
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - ancient civilization
+    - ancient people
+  inconsiderate: ancient man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - author
+    - writer
+  inconsiderate: authoress
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - average consumer
+    - average household
+    - average homemaker
+  inconsiderate: average housewife
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: average person
+  inconsiderate: average man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - average wage earner
+    - average taxpayer
+  inconsiderate: average working man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: aviator
+  inconsiderate: aviatrix
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: the human family
+  inconsiderate: brotherhood of man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: model
+  inconsiderate: calendar girl
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - escort
+    - prostitute
+    - sex worker
+  inconsiderate: call girl
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - cleric
+    - practicing Christian
+    - pillar of the Church
+  inconsiderate: churchman
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - english coordinator
+    - senior teacher of english
+  inconsiderate: english master
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: the english
+  inconsiderate: englishmen
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: executor
+  inconsiderate: executrix
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: founder of
+  inconsiderate: father of *
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - the founders
+    - founding leaders
+    - forebears
+  inconsiderate: founding father
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - house worker
+    - domestic help
+  inconsiderate: housemaid
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - industrial civilization
+    - industrial people
+  inconsiderate: industrial man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: doctor
+  inconsiderate: lady doctor
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: lead
+  inconsiderate: leading lady
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: virgin
+  inconsiderate: maiden
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: first race
+  inconsiderate: maiden race
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: first speech
+  inconsiderate: maiden speech
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: staff a desk
+  inconsiderate: man a desk
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - ordinary citizen
+    - typical person
+    - average person
+  inconsiderate: man in the street
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - farmer
+    - rural worker
+    - grazier
+    - landowner
+    - rural community
+    - country people
+    - country folk
+  inconsiderate: man of the land
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: a faithful dog
+  inconsiderate: mans best friend
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: staff the booth
+  inconsiderate: man the booth
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: answer the phones
+  inconsiderate: man the phones
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - a demanding task
+    - a big job
+  inconsiderate:
+    - mansized task
+    - man sized task
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - pass key
+    - original
+  inconsiderate:
+    - master key
+    - master copy
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - grand scheme
+    - guiding principles
+  inconsiderate: master plan
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: become skilled
+  inconsiderate: master the art
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: scientists
+  inconsiderate: men of science
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: birthing nurse
+  inconsiderate: midwife
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - modern civilization
+    - modern people
+  inconsiderate: modern man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - unoccupied territory
+    - wasteland
+    - deathtrap
+  inconsiderate: no mans land
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: administrative staff
+  inconsiderate: office girls
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: poet
+  inconsiderate: poetess
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: railway worker
+  inconsiderate: railwayman
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - fair
+    - sporting
+  inconsiderate: sportsmanlike
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - fairness
+    - good humor
+    - sense of fair play
+  inconsiderate: sportsmanship
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: diplomatic
+  inconsiderate:
+    - statesmanlike
+    - statesman like
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - cattle worker
+    - farmhand
+    - drover
+  inconsiderate: stockman
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: service entrance
+  inconsiderate: tradesmans entrance
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - tax commissioner
+    - tax office
+    - tax collector
+  inconsiderate: tax man
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: usher
+  inconsiderate: usherette
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: lawyer
+  inconsiderate: woman lawyer
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate: painter
+  inconsiderate: woman painter
+- type: basic
+  source: https://radyananda.wordpress.com/2009/06/06/nonsexist-alternative-language-handbook-for-conscious-writers/
+  considerate:
+    - wage or salary earning woman
+    - two-income family
+  inconsiderate:
+    - working mother
+    - working wife

app/data/en/lgbtq.yml

@@ -0,0 +1,206 @@
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: This term has a clinical history and is used to imply LGBTQ+ people are diseased or psychologically/emotionally disordered
+  considerate:
+    - gay
+    - gay man
+    - lesbian
+    - gay person/people
+  inconsiderate:
+    - homosexual
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: Avoid labeling something as LGBTQ+ unless you would call the same thing “straight”
+  considerate:
+    - relationship
+  inconsiderate:
+    - homosexual relations
+    - homosexual relationship
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: Avoid labeling something as LGBTQ+ unless you would call the same thing “straight”
+  considerate:
+    - couple
+  inconsiderate:
+    - homosexual couple
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: Implies that being LGBTQ+ is a choice
+  considerate:
+    - sexual orientation
+    - orientation
+  inconsiderate:
+    - sexual preference
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: Implies that being LGBTQ+ is a choice
+  considerate:
+    - gay lives
+    - gay/lesbian lives
+  inconsiderate:
+    - gay lifestyle
+    - homosexual lifestyle
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: Used by anti-LGBTQ+ extremists to create a climate of fear around LGBTQ+ issues
+  considerate:
+    - gay issues
+  inconsiderate:
+    - gay agenda
+    - homosexual agenda
+- type: basic
+  source: https://www.glaad.org/reference/style
+  note: LGBTQ+ rights are human rights
+  considerate:
+    - equal rights
+    - civil rights for gay people
+  inconsiderate:
+    - special rights
+    - gay rights
+- type: basic
+  source: https://www.glaad.org/reference/offensive
+  note: Derogatory terms for LGBTQ+ people are offensive
+  considerate:
+    - gay
+  inconsiderate:
+    - fag
+    - faggot
+    - dyke
+    - homo
+    - sodomite
+- type: basic
+  source: https://www.glaad.org/reference/style
+  note: Avoid using slang shorthand
+  considerate:
+    - bisexual
+  inconsiderate:
+    - bi
+- type: basic
+  source: https://www.glaad.org/reference/style
+  note: Homosexual has a clinical history and is used to imply LGBTQ+ people are diseased or psychologically/emotionally disordered
+  considerate:
+    - gay marriage
+    - same-sex marriage
+  inconsiderate:
+    - homosexual marriage
+- type: basic
+  source: https://www.glaad.org/reference/style
+  note: Derogatory terms for LGBTQ+ people are offensive
+  considerate:
+    - transgender
+  inconsiderate:
+    - tranny
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: Avoid using outdated / offensive terms
+  considerate:
+    - cross-dresser
+  inconsiderate:
+    - transvestite
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: Avoid overemphasizing surgery when discussing transgender people or the process of transition - it’s not a necessary component
+  considerate:
+    - transition
+    - gender confirmation surgery
+  inconsiderate:
+    - sexchange
+    - sex change
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: Shift focus away from the assigned sex and towards the identified gender
+  considerate:
+    - sex reassignment surgery
+    - gender confirmation surgery
+  inconsiderate:
+    - sex change operation
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: Transgender should be used as an adjective, not as a noun
+  considerate:
+    - transgender people
+  inconsiderate:
+    - transgenders
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: Transgender is already an adjective
+  considerate:
+    - transgender
+  inconsiderate:
+    - transgendered
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: This is a term used by anti-transgender activists to dehumanize transgender people and reduce who they are to a condition
+  considerate:
+    - being transgender
+    - the movement for transgender equality
+  inconsiderate:
+    - transgenderism
+- type: basic
+  note: Assigned birth gender is complicated; gender identity is more than what your parents decided you were at birth
+  considerate:
+    - assigned male at birth
+    - designated male at birth
+  inconsiderate:
+    - biologically male
+    - born a man
+    - genetically male
+- type: basic
+  note: Assigned birth gender is complicated; gender identity is more than what your parents decided you were at birth
+  considerate:
+    - assigned female at birth
+    - designated female at birth
+  inconsiderate:
+    - biologically female
+    - born a woman
+    - genetically female
+- type: basic
+  source: https://www.glaad.org/reference/transgender
+  note: A term created and used by far-right extremists to oppose nondiscrimination laws that protect transgender people
+  considerate:
+    - non-discrimination law
+    - non-discrimination ordinance
+  inconsiderate:
+    - bathroom bill
+- type: basic
+  source: http://www.isna.org/node/979
+  note: These terms are stigmatizing to patients and their families because intersex status is more complicated than the mere presence or absence of certain gonadal tissues
+  considerate:
+    - intersex
+  inconsiderate:
+    - hermaphroditic
+    - pseudohermaphroditic
+    - pseudo hermaphroditic
+- type: basic
+  source: http://www.isna.org/node/979
+  note: These terms are stigmatizing to patients and their families because intersex status is more complicated than the mere presence or absence of certain gonadal tissues
+  considerate:
+    - person who is intersex
+    - person
+    - intersex person
+  inconsiderate:
+    - hermaphrodite
+    - pseudohermaphrodite
+    - pseudo hermaphrodite
+- type: basic
+  source: https://www.reddit.com/r/asktransgender/comments/23wbq1/is_the_term_shemale_seen_as_offensive/
+  note: This word dehumanizes transgender people
+  considerate:
+    - transgender person
+    - person
+  inconsiderate:
+    - shemale
+    - she male
+    - heshe
+    - shehe
+- type: basic
+  source: https://www.selfdefined.app/definitions/pronouns/
+  note: Preferred pronoun sounds like it is optional to use someone's correct pronoun
+  considerate:
+    - pronoun
+    - pronouns
+  inconsiderate:
+    - preferred pronoun
+    - preferred pronouns
+    - gender pronoun
+    - gender pronouns

app/data/en/misc.yml

@@ -0,0 +1,19 @@
+- type: basic
+  note: Avoid using terms that implies colonialism/genocide against Indigenous peoples
+  considerate:
+    - keep an eye on things
+    - keep shop
+    - provide coverage
+    - cover things
+    - take charge
+  inconsiderate:
+    - man the fort
+- type: basic
+  note: Avoid using terms that relate to gun violence.
+  considerate:
+    - go for it
+    - take a chance
+    - make a move
+    - take action
+  inconsiderate:
+    - pull the trigger

app/data/en/press.yml

@@ -0,0 +1,20 @@
+- type: basic
+  source: https://www.usnews.com/news/newsgram/articles/2013/04/04/the-associated-press-revises-islamist-another-politically-charged-term
+  considerate:
+    - muslim
+    - person of Islamic faith
+    - fanatic
+    - zealot
+    - follower of islam
+    - follower of the islamic faith
+  inconsiderate:
+    - islamist
+- type: basic
+  source: https://www.usnews.com/news/newsgram/articles/2013/04/04/the-associated-press-revises-islamist-another-politically-charged-term
+  considerate:
+    - muslims
+    - people of Islamic faith
+    - fanatics
+    - zealots
+  inconsiderate:
+    - islamists

app/data/en/race.yml

@@ -0,0 +1,370 @@
+- type: basic
+  note: Avoid using the term `master`; these suggestions are for the computer term, but there are better alternatives for other cases too
+  considerate:
+    - primary
+    - lead
+    - hub
+    - reference
+  inconsiderate:
+    - master
+- type: basic
+  note: Avoid using the term `master`; these suggestions are for the computer term, but there are better alternatives for other cases too
+  considerate:
+    - primaries
+    - hubs
+    - references
+  inconsiderate:
+    - masters
+- type: basic
+  note: Avoid using the term `slave`; these suggestions are for the computer term, but there are better alternatives for other cases too
+  considerate:
+    - secondary
+    - worker
+    - replica
+    - node
+  inconsiderate:
+    - slave
+- type: basic
+  note: Avoid using the term `slave`; these suggestions are for the computer term, but there are better alternatives for other cases too
+  considerate:
+    - secondaries
+    - workers
+    - replicas
+    - nodes
+  inconsiderate:
+    - slaves
+- type: basic
+  considerate:
+    - unethical hacker
+    - malicious actor
+  inconsiderate:
+    - blackhat
+- type: basic
+  considerate:
+    - ethical hacker
+    - security researcher
+  inconsiderate:
+    - whitehat
+- type: basic
+  considerate:
+    - Inuit
+  inconsiderate:
+    - eskimo
+- type: basic
+  considerate:
+    - Inuits
+  inconsiderate:
+    - eskimos
+- type: basic
+  considerate:
+    - Asian person
+  inconsiderate:
+    - oriental
+- type: basic
+  considerate:
+    - Asian people
+  inconsiderate:
+    - orientals
+- type: basic
+  considerate:
+    - person of color
+    - people of color
+  inconsiderate:
+    - nonwhite
+    - non white
+- type: basic
+  considerate:
+    - projects
+    - urban
+  inconsiderate:
+    - ghetto
+- type: basic
+  considerate:
+    - Native American
+  inconsiderate:
+    - red indian
+    - pocahontas
+    - redskin
+- type: basic
+  considerate:
+    - Native American People
+  inconsiderate:
+    - red indians
+    - redskins
+- type: basic
+  inconsiderate:
+    - animal spirit
+    - dream catcher
+    - spirit animal
+    - totem
+  note: Avoid using terms that oversimplify the complex and varied beliefs of indigenous religions.
+  source:
+    - https://www.worldreligionnews.com/opinion/spirit-animal-not-joke-oppression
+    - https://www.spiralnature.com/spirituality/spirit-animal-cultural-appropriation
+  considerate:
+    - favorite
+    - inspiration
+    - personal interest
+    - personality type
+- type: basic
+  inconsiderate:
+    - long time no hear
+    - long time no see
+  note: Avoid using phrases that implicitly mock people with limited knowledge of the English language.
+  source: https://www.npr.org/sections/codeswitch/2014/03/09/288300303/who-first-said-long-time-no-see-and-in-which-language
+  considerate:
+    - I haven’t seen you in a long time
+    - it’s been a long time
+- type: basic
+  inconsiderate:
+    - Indian country
+  note: Avoid using phrases referring to the genocidal United States “Indian Removal” laws.
+  source:
+    - https://newsmaven.io/indiancountrytoday/archive/off-the-reservation-a-teachable-moment-nW1d7U0JRkOszhtg8N1V1A/
+  considerate:
+    - enemy territory
+- type: basic
+  inconsiderate:
+    - jump the reservation
+    - off reserve
+    - off the reservation
+  note: Avoid using phrases referring to the genocidal United States “Indian Removal” laws.
+  source:
+    - http://blog.nativepartnership.org/off-the-reservation/
+    - https://www.wsj.com/articles/off-the-reservation-is-a-phrase-with-a-dark-past-1462552837
+    - https://www.npr.org/sections/codeswitch/2014/06/29/326690947/should-saying-someone-is-off-the-reservation-be-off-limits
+    - https://nowtoronto.com/news/native-references-and-terms-that-are-offensive-to-indigenous-people/
+  considerate:
+    - disobey
+    - endure
+    - object to
+    - oppose
+    - resist
+- type: basic
+  inconsiderate:
+    - circle the wagons
+    - on the warpath
+  note: Avoid using phrases referring to colonial stereotypes regarding Native Americans.
+  source:
+    - https://idioms.thefreedictionary.com/circle+the+wagons
+    - https://idioms.thefreedictionary.com/go+on+the+warpath
+  considerate:
+    - defend
+- type: basic
+  inconsiderate:
+    - too many chiefs
+  note: Avoid using phrases referring to colonial stereotypes regarding Native Americans.
+  source:
+    - https://idioms.thefreedictionary.com/too+many+chiefs+and+not+enough+Indians
+  considerate:
+    - too many chefs in the kitchen
+    - too many cooks spoil the broth
+- type: basic
+  inconsiderate:
+    - natives are restless
+    - natives are becoming restless
+    - natives are getting restless
+    - natives are growing restless
+  note: Avoid using phrases referring to colonial stereotypes regarding indigenous peoples.
+  source:
+    - https://tvtropes.org/pmwiki/pmwiki.php/Main/TheNativesAreRestless
+  considerate:
+    - dissatisfied
+    - frustrated
+- type: basic
+  inconsiderate:
+    - pow wow
+    - powwow
+  note: Avoid casually using this term, which refers to traditional indigenous celebration ceremonies that were banned by genocidal laws in the United States and Canada — Native people died fighting for this right.
+  source:
+    - https://twitter.com/chadloder/status/1203507070772793345
+    - http://nativeappropriations.com/2012/09/paul-frank-offends-every-native-person-on-the-planet-with-fashion-night-out-dream-catchin-pow-wow.html
+    - https://www.britannica.com/topic/powwow
+    - https://nowtoronto.com/news/native-references-and-terms-that-are-offensive-to-indigenous-people/
+  considerate:
+    - conference
+    - gathering
+    - meeting
+- type: basic
+  note: Avoid using phrases referring to colonial stereotypes regarding Native Americans.
+  considerate:
+    - go back on one’s offer
+  inconsiderate:
+    - indian give
+    - indian giver
+- type: basic
+  considerate:
+    - Filipinos
+    - Filipino people
+  inconsiderate:
+    - pinoys
+    - pinays
+- type: basic
+  considerate:
+    - Arabs
+    - Middle Eastern People
+  inconsiderate:
+    - towel heads
+- type: basic
+  note: Whenever possible, try to be gender inclusive.
+  considerate:
+    - Latinx
+  inconsiderate:
+    - latino
+    - latina
+- type: basic
+  considerate:
+    - Japanese person
+    - Japanese people
+  inconsiderate:
+    - japs
+- type: basic
+  considerate:
+    - Jewish person
+  inconsiderate:
+    - shlomo
+    - shyster
+    - hymie
+- type: basic
+  considerate:
+    - a person who is not Jewish
+    - not Jewish
+  inconsiderate:
+    - goyim
+    - goyum
+    - goy
+- type: basic
+  considerate:
+    - a Black person
+  inconsiderate:
+    - spade
+- type: basic
+  source: en.wikipedia.org/wiki/Romani_people#cite_ref-80
+  note: Gypsy is insensitive, use Roma or Romani. They’re not Egyptian as the name suggests.
+  considerate:
+    - Nomad
+    - Traveler
+    - Roma
+    - Romani
+  inconsiderate:
+    - gyppo
+    - gypsy
+    - Gipsy
+    - gyp
+- type: basic
+  note: Replace racially-charged language with more accurate and inclusive words
+  considerate:
+    - blocklist
+    - wronglist
+    - banlist
+    - deny list
+  inconsiderate:
+    - blacklist
+    - black list
+- type: basic
+  note: Replace racially-charged language with more accurate and inclusive words
+  considerate:
+    - blocklisted
+    - wronglisted
+    - banlisted
+    - deny-listed
+  inconsiderate:
+    - blacklisted
+- type: basic
+  note: Replace racially-charged language with more accurate and inclusive words
+  considerate:
+    - blocklisting
+    - wronglisting
+    - banlisting
+    - deny-listing
+  inconsiderate:
+    - blacklisting
+- type: basic
+  note: Replace racially-charged language with more accurate and inclusive words
+  considerate:
+    - passlist
+    - alrightlist
+    - safelist
+    - allow list
+  inconsiderate:
+    - whitelist
+    - white list
+- type: basic
+  note: Replace racially-charged language with more accurate and inclusive words
+  considerate:
+    - passlisted
+    - alrightlisted
+    - safelisted
+    - allow-listed
+  inconsiderate:
+    - whitelisted
+- type: basic
+  note: Replace racially-charged language with more accurate and inclusive words
+  considerate:
+    - passlisting
+    - alrightlisting
+    - safelisting
+    - allow-listing
+  inconsiderate:
+    - whitelisting
+- type: basic
+  note: Avoid using terms that imply a group has not changed over time and that they are inferior
+  considerate:
+    - simple
+    - indigenous
+    - hunter-gatherer
+  inconsiderate:
+    - primitive
+    - savage
+    - stone age
+- type: basic
+  note: Avoid using terms that make some groups sound inferior
+  considerate:
+    - society
+    - community
+  inconsiderate:
+    - tribe
+- type: basic
+  note: Avoid using terms that make some groups sound inferior. Replace “sophisticated” with a neutral term such as “complex”
+  considerate:
+    - complex culture
+  inconsiderate:
+    - sophisticated culture
+- type: basic
+  note: Avoid using terms that make some groups sound inferior. Replace “sophisticated” with a neutral term such as “complex”
+  considerate:
+    - complex technology
+  inconsiderate:
+    - sophisticated technology
+- type: basic
+  note: Avoid using `bugreport`, as the word `bugre` is a slur in Brazilian Portuguese
+  considerate:
+    - bug report
+    - snapshot
+  inconsiderate:
+    - bugreport
+- type: basic
+  source: https://en.wikipedia.org/wiki/Grandfather_clause#Origin
+  note: Avoid using phrases referring to racist United States “Jim Crow” laws.
+  considerate:
+    - legacy policy
+    - legacy clause
+    - deprecation policy
+  inconsiderate:
+    - grandfather clause
+    - grandfather policy
+- type: basic
+  source: https://en.wikipedia.org/wiki/Grandfather_clause#Origin
+  note: Avoid using phrases referring to racist United States “Jim Crow” laws.
+  considerate:
+    - deprecate
+  inconsiderate:
+    - grandfathering
+- type: basic
+  source: https://en.wikipedia.org/wiki/Grandfather_clause#Origin
+  note: Avoid using phrases referring to racist United States “Jim Crow” laws.
+  considerate:
+    - deprecated
+    - legacy
+  inconsiderate:
+    - grandfathered

app/data/en/slogans.yml

@@ -0,0 +1,9 @@
+- type: basic
+  considerate:
+    - improve
+  inconsiderate:
+    - make * great again
+    - make * * great again
+    - make * * * great again
+    - make * * * * great again
+    - make * * * * * great again

app/data/en/suicide.yml

@@ -0,0 +1,51 @@
+- type: basic
+  source: https://www.afsp.org/news-events/for-the-media/reporting-on-suicide, https://www.speakingofsuicide.com/2013/04/13/language/
+  considerate:
+    - died by suicide
+  inconsiderate:
+    - committed suicide
+    - completed suicide
+- type: basic
+  source: https://www.afsp.org/news-events/for-the-media/reporting-on-suicide, https://www.speakingofsuicide.com/2013/04/13/language/
+  note: Committing suicide is not successful/unsuccessful, that sends the wrong message
+  considerate:
+    - die by suicide
+  inconsiderate:
+    - commit suicide
+    - complete suicide
+    - successful suicide
+- type: basic
+  source: https://www.afsp.org/news-events/for-the-media/reporting-on-suicide
+  note: Using sensational words can cause copycat suicides or contagion
+  considerate:
+    - rise in suicides
+  inconsiderate:
+    - suicide epidemic
+    - epidemic of suicides
+    - suicide pact
+- type: basic
+  source: https://www.speakingofsuicide.com/2013/04/13/language, https://www.afsp.org/news-events/for-the-media/reporting-on-suicide
+  note: Attempted suicide should not be depicted as a failure
+  considerate:
+    - suicide attempt
+    - attempted suicide
+  inconsiderate:
+    - failed suicide
+    - failed attempt
+    - suicide failure
+- type: basic
+  source: https://www.afsp.org/news-events/for-the-media/reporting-on-suicide
+  considerate:
+    - a note from the deceased
+  inconsiderate:
+    - suicide note
+- type: basic
+  note: When describing the behavior of computer software, using the word “hanged” needlessly invokes the topic of death by self-harm or lynching.  Consider using the word “froze” or the phrase “stopped responding to events” or “became unresponsive” instead.
+  considerate:
+    - the app froze
+    - the app stopped responding
+    - the app stopped responding to events
+    - the app became unresponsive
+  inconsiderate:
+    - hang
+    - hanged

app/main.py

@@ -1,48 +1,5 @@
-from fastapi import FastAPI
-import logging # Import logging module
+from app.core.app import create_app
+from app.core.logging import configure_logging
 
-# Configure basic logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Import all individual routers for different functionalities
-from app.routers import (
-    grammar,
-    punctuation,
-    sentence_correctness,
-    tone,
-    voice,
-    inclusive_language,
-    vocabulary,
-    conciseness,
-    readability,
-    paraphrase,
-    translate,
-    summarize
-)
-
-# Initialize the FastAPI application
-app = FastAPI()
-
-@app.get("/")
-def root():
-    """
-    Root endpoint for the API.
-    Returns a welcome message.
-    """
-    logger.info("Root endpoint accessed.")
-    return {"message": "Welcome to Grammafree API"}
-
-# Include all the individual routers for modular API structure.
-app.include_router(grammar.router)            # Grammar correction and diffs
-app.include_router(punctuation.router)        # Punctuation fixes
-app.include_router(sentence_correctness.router) # Sentence correctness feedback
-app.include_router(tone.router)               # Tone detection and suggestions
-app.include_router(voice.router)              # Active/Passive voice detection
-app.include_router(inclusive_language.router) # Inclusive language rewriting
-app.include_router(vocabulary.router)         # Vocabulary enhancement
-app.include_router(conciseness.router)        # Conciseness suggestions
-app.include_router(readability.router)        # Readability scores
-app.include_router(paraphrase.router)         # Existing paraphrasing functionality
-app.include_router(translate.router)          # Existing translation functionality
-app.include_router(summarize.router)          # Existing summarization functionality
+configure_logging()
+app = create_app()

app/models.py

@@ -1,108 +0,0 @@
-from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, pipeline
-import torch
-
-# Set the device for model inference (CPU is used by default)
-# You can change to "cuda" if a compatible GPU is available for faster processing.
-device = torch.device("cpu")
-
-# --- Grammar model ---
-# Changed to deepashri/t5-small-grammar-correction, a publicly available model
-# for grammatical error correction. This model is fine-tuned from T5-small.
-grammar_tokenizer = AutoTokenizer.from_pretrained("AventIQ-AI/t5-small-grammar-correction")
-grammar_model = AutoModelForSeq2SeqLM.from_pretrained("AventIQ-AI/t5-small-grammar-correction").to(device)
-
-# --- FLAN-T5 for all prompts ---
-# Uses google/flan-t5-small for various text generation tasks based on prompts,
-# such as paraphrasing, summarizing, and generating tone suggestions.
-flan_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
-flan_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small").to(device)
-
-# --- Translation model ---
-# Uses Helsinki-NLP/opus-mt-en-ROMANCE for English to Romance language translation.
-trans_tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-ROMANCE")
-trans_model = AutoModelForSeq2SeqLM.from_pretrained("Helsinki-NLP/opus-mt-en-ROMANCE").to(device)
-
-# --- Tone classification model ---
-# Uses j-hartmann/emotion-english-distilroberta-base for detecting emotions/tones
-# within text. This provides a more nuanced analysis than simple positive/negative.
-# 'top_k=1' ensures that only the most confident label is returned.
-tone_classifier = pipeline("sentiment-analysis", model="j-hartmann/emotion-english-distilroberta-base", top_k=1)
-
-def run_grammar_correction(text: str) -> str:
-    """
-    Corrects the grammar of the input text using the pre-trained T5 grammar model.
-
-    Args:
-        text (str): The input text to be grammatically corrected.
-
-    Returns:
-        str: The corrected text.
-    """
-    # Prepare the input for the grammar model by prefixing with "grammar: " as per
-    # the 'deepashri/t5-small-grammar-correction' model's expected input format.
-    # Some grammar correction models expect a specific prefix like "grammar: " or "fix: ".
-    inputs = grammar_tokenizer(f"grammar: {text}", return_tensors="pt").to(device)
-    # Generate the corrected output
-    outputs = grammar_model.generate(**inputs)
-    # Decode the generated tokens back into a readable string, skipping special tokens
-    return grammar_tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-def run_flan_prompt(prompt: str) -> str:
-    """
-    Runs a given prompt through the FLAN-T5 model to generate a response.
-    Includes advanced generation parameters for better output quality.
-
-    Args:
-        prompt (str): The prompt string to be processed by FLAN-T5.
-
-    Returns:
-        str: The generated text response from FLAN-T5.
-    """
-    # Prepare the input for the FLAN-T5 model
-    inputs = flan_tokenizer(prompt, return_tensors="pt").to(device)
-    
-    # Generate the output with improved parameters:
-    outputs = flan_model.generate(
-        **inputs,
-        max_new_tokens=100,
-        num_beams=5,
-        do_sample=True,
-        top_k=50,
-        top_p=0.95,
-        temperature=0.7
-    )
-    # Decode the generated tokens back into a readable string
-    return flan_tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-def run_translation(text: str, target_lang: str) -> str:
-    """
-    Translates the input text to the target language using the Helsinki-NLP translation model.
-
-    Args:
-        text (str): The input text to be translated.
-        target_lang (str): The target language code (e.g., "fr" for French, "es" for Spanish).
-
-    Returns:
-        str: The translated text.
-    """
-    # Prepare the input for the translation model by specifying the target language
-    inputs = trans_tokenizer(f">>{target_lang}<< {text}", return_tensors="pt").to(device)
-    # Generate the translated output
-    outputs = trans_model.generate(**inputs)
-    # Decode the generated tokens back into a readable string
-    return trans_tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-def classify_tone(text: str) -> str:
-    """
-    Classifies the emotional tone of the input text using the pre-trained emotion classifier.
-
-    Args:
-        text (str): The input text for tone classification.
-
-    Returns:
-        str: The detected emotional label (e.g., 'neutral', 'joy', 'sadness', 'anger', 'fear', 'disgust', 'surprise').
-    """
-    # The tone_classifier returns a list of dictionaries, where each dictionary
-    # contains 'label' and 'score'. We extract the 'label' from the first (and only) result.
-    result = tone_classifier(text)[0][0]
-    return result['label']

app/prompts.py

@@ -1,121 +0,0 @@
-def tone_prompt(text: str, tone: str) -> str:
-    """
-    Generates a prompt to rewrite text in a specified tone.
-
-    Args:
-        text (str): The original text.
-        tone (str): The desired tone (e.g., "formal", "informal", "confident").
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Rewrite the following text in a {tone} tone: {text}"
-
-def clarity_prompt(text: str) -> str:
-    """
-    Generates a prompt to make text clearer.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Make this clearer: {text}"
-
-def fluency_prompt(text: str) -> str:
-    """
-    Generates a prompt to improve the fluency of a sentence.
-
-    Args:
-        text (str): The original sentence.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Improve the fluency of this sentence: {text}"
-
-def paraphrase_prompt(text: str) -> str:
-    """
-    Generates a prompt to paraphrase text.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Paraphrase: {text}"
-
-def summarize_prompt(text: str) -> str:
-    """
-    Generates a prompt to summarize text.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Summarize: {text}"
-
-def pronoun_friendly_prompt(text: str) -> str:
-    """
-    Generates a prompt to rewrite text using inclusive, respectful language,
-    avoiding gender-specific pronouns.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Rewrite the following text using inclusive, respectful language avoiding gender-specific pronouns: {text}"
-
-def active_voice_prompt(text: str) -> str:
-    """
-    Generates a prompt to detect passive/active voice and suggest an active voice version if passive.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Detect if this is passive or active voice. If passive, suggest an active voice version: {text}"
-
-def tone_analysis_prompt(text: str) -> str:
-    """
-    Generates a prompt to analyze the tone of text and suggest improvements.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Analyze the tone of the following text and suggest improvements if needed: {text}"
-
-def vocabulary_prompt(text: str) -> str:
-    """
-    Generates a prompt to suggest vocabulary improvements for the given text.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"For the following text, identify any weak or overused words and suggest stronger, more precise synonyms or alternative phrasing. Provide suggestions as a list of 'original word/phrase -> suggested word/phrase': {text}"
-
-def conciseness_prompt(text: str) -> str:
-    """
-    Generates a prompt to make the given text more concise.
-
-    Args:
-        text (str): The original text.
-
-    Returns:
-        str: The generated prompt.
-    """
-    return f"Rewrite the following text to be more concise, removing any unnecessary words or phrases while retaining the original meaning: {text}"

app/routers/conciseness.py

@@ -1,42 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
-from app.core.security import verify_api_key
-import logging # Import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-class ConcisenessInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /conciseness_check endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/conciseness_check", dependencies=[Depends(verify_api_key)])
-def conciseness_check(payload: ConcisenessInput):
-    """
-    Provides suggestions for making text more concise.
-
-    Args:
-        payload (ConcisenessInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing the concise version of the text.
-    """
-    text = payload.text
-    
-    try:
-        concise_text = models.run_flan_prompt(prompts.conciseness_prompt(text))
-        
-        return {
-            "concise_version": concise_text
-        }
-    except Exception as e:
-        logger.error(f"Error in conciseness_check: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during conciseness checking: {e}"
-        )

app/routers/grammar.py

@@ -1,61 +1,60 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models
+from fastapi import APIRouter, Depends, HTTPException, status
+from app.schemas.base import TextOnlyRequest
+from app.services.grammar import GrammarCorrector
 from app.core.security import verify_api_key
 import difflib
-import logging # Import logging
+import logging
 
+router = APIRouter(prefix="/grammar", tags=["Grammar"])
+corrector = GrammarCorrector()
 logger = logging.getLogger(__name__)
 
-router = APIRouter()
-
-class GrammarInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /grammar_check endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/grammar_check", dependencies=[Depends(verify_api_key)])
-def grammar_check(payload: GrammarInput):
-    """
-    Corrects the grammar of the provided text and shows changes.
-
-    Args:
-        payload (GrammarInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing the corrected text and a list of changes.
-    """
-    original_text = payload.text
-    
-    try:
-        corrected_text = models.run_grammar_correction(original_text)
-        
-        grammar_changes = []
-        s = difflib.SequenceMatcher(None, original_text.split(), corrected_text.split())
-        
-        for opcode, i1, i2, j1, j2 in s.get_opcodes():
-            if opcode == 'replace':
-                original_part = ' '.join(original_text.split()[i1:i2])
-                corrected_part = ' '.join(corrected_text.split()[j1:j2])
-                grammar_changes.append(f"'{original_part}' \u2192 '{corrected_part}'")
-            elif opcode == 'delete':
-                deleted_part = ' '.join(original_text.split()[i1:i2])
-                grammar_changes.append(f"'{deleted_part}' removed")
-            elif opcode == 'insert':
-                inserted_part = ' '.join(corrected_text.split()[j1:j2])
-                grammar_changes.append(f"'{inserted_part}' added")
-
-        return {
-            "grammar": {
-                "corrected": corrected_text,
-                "changes": grammar_changes
-            }
+def get_diff_issues(original: str, corrected: str):
+    matcher = difflib.SequenceMatcher(None, original, corrected)
+    issues = []
+
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            continue
+
+        issue = {
+            "offset": i1,
+            "length": i2 - i1,
+            "original": original[i1:i2],
+            "suggestion": corrected[j1:j2],
+            "context_before": original[max(0, i1 - 15):i1],
+            "context_after": original[i2:i2 + 15],
+            "message": "Grammar correction",
+            "line": original[:i1].count("\n") + 1,
+            "column": i1 - original[:i1].rfind("\n") if "\n" in original[:i1] else i1 + 1
         }
-    except Exception as e:
-        logger.error(f"Error in grammar_check: {e}", exc_info=True)
+        issues.append(issue)
+
+    return issues
+
+@router.post("/", dependencies=[Depends(verify_api_key)])
+def correct_grammar(payload: TextOnlyRequest):
+    text = payload.text.strip()
+
+    if not text:
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during grammar checking: {e}"
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Input text cannot be empty."
         )
+
+    corrected = corrector.correct(text)
+
+    if corrected.startswith("Input text is empty."):
+        raise HTTPException(status_code=400, detail="Input text cannot be empty.")
+    elif corrected.startswith("An error occurred during grammar correction."):
+        raise HTTPException(status_code=500, detail=corrected)
+
+    issues = get_diff_issues(text, corrected)
+
+    return {
+        "grammar": {
+            "original_text": text,
+            "corrected_text_suggestion": corrected,
+            "issues": issues
+        }
+    }

app/routers/inclusive_language.py

@@ -1,42 +1,11 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
+from fastapi import APIRouter, Depends
+from app.schemas.base import TextOnlyRequest
+from app.services.inclusive_language import InclusiveLanguageChecker
 from app.core.security import verify_api_key
-import logging # Import logging
 
-logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/inclusive-language", tags=["Inclusive Language"])
+checker = InclusiveLanguageChecker()
 
-router = APIRouter()
-
-class InclusiveLanguageInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /inclusive_language endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/inclusive_language", dependencies=[Depends(verify_api_key)])
-def inclusive_language_check(payload: InclusiveLanguageInput):
-    """
-    Provides suggestions for rewriting text using inclusive language.
-
-    Args:
-        payload (InclusiveLanguageInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing the rewritten text with inclusive language.
-    """
-    text = payload.text
-    
-    try:
-        inclusive_text = models.run_flan_prompt(prompts.pronoun_friendly_prompt(text))
-        
-        return {
-            "inclusive_pronouns": inclusive_text
-        }
-    except Exception as e:
-        logger.error(f"Error in inclusive_language_check: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during inclusive language check: {e}"
-        )
+@router.post("/", dependencies=[Depends(verify_api_key)])
+def check_inclusive_language(payload: TextOnlyRequest):
+    return {"suggestions": checker.check(payload.text)}

app/routers/paraphrase.py

@@ -1,39 +1,12 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
+from fastapi import APIRouter, Depends
+from app.schemas.base import TextOnlyRequest
+from app.services.paraphrase import Paraphraser
 from app.core.security import verify_api_key
-import logging # Import logging
 
-logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/paraphrase", tags=["Paraphrase"])
+paraphraser = Paraphraser()
 
-router = APIRouter()
-
-class ParaphraseInput(BaseModel): # Renamed Input to ParaphraseInput for clarity
-    """
-    Pydantic BaseModel for validating the input request body for the /paraphrase endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/paraphrase", dependencies=[Depends(verify_api_key)])
-def paraphrase(payload: ParaphraseInput): # Renamed input to payload for consistency
-    """
-    Paraphrases the provided text.
-
-    Args:
-        payload (ParaphraseInput): The request body containing the text to be paraphrased.
-
-    Returns:
-        dict: A dictionary containing the paraphrased text.
-    """
-    text = payload.text
-    
-    try:
-        paraphrased_text = models.run_flan_prompt(prompts.paraphrase_prompt(text))
-        return {"result": paraphrased_text}
-    except Exception as e:
-        logger.error(f"Error in paraphrase: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during paraphrasing: {e}"
-        )
+@router.post("/", dependencies=[Depends(verify_api_key)])
+def paraphrase_text(payload: TextOnlyRequest):
+    result = paraphraser.paraphrase(payload.text)
+    return {"result": result}

app/routers/punctuation.py

@@ -1,67 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app.core.security import verify_api_key
-import language_tool_python
-import logging # Import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-# Initialize LanguageTool. This will be the same instance as used for punctuation.
-# Ensure Java is installed in your environment.
-try:
-    tool = language_tool_python.LanguageTool('en-US')
-except Exception as e:
-    logger.error(f"Failed to initialize LanguageTool: {e}", exc_info=True)
-    # If LanguageTool cannot be initialized, raise an error or handle gracefully
-    # For an MVP, we might let the app start but fail on requests that use it.
-    # A more robust solution might mark the endpoint as unavailable.
-    tool = None # Set to None if initialization fails
-
-class PunctuationInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /punctuation_check endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/punctuation_check", dependencies=[Depends(verify_api_key)])
-def punctuation_check(payload: PunctuationInput):
-    """
-    Checks the provided text for punctuation errors.
-
-    Args:
-        payload (PunctuationInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing a list of punctuation issues.
-    """
-    if tool is None:
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Punctuation check service is not available (LanguageTool failed to initialize)."
-        )
-
-    text = payload.text
-    
-    try:
-        matches = tool.check(text)
-        
-        punctuation_issues = []
-        for m in matches:
-            if 'PUNCTUATION' in m.ruleId.upper():
-                punctuation_issues.append(m.message)
-                
-        return {
-            "punctuation": {
-                "issues": punctuation_issues,
-                "suggestions": [] # Suggestions might be handled by overall grammar correction
-            }
-        }
-    except Exception as e:
-        logger.error(f"Error in punctuation_check: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during punctuation checking: {e}"
-        )

app/routers/readability.py

@@ -1,55 +1,33 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
+from fastapi import APIRouter, Depends, HTTPException, status
+from app.schemas.base import TextOnlyRequest
 from app.core.security import verify_api_key
-import textstat # Import the textstat library
-import logging # Import logging
+from app.utils.shared import executor
+import asyncio
+import logging
+import textstat
 
+router = APIRouter(prefix="/readability", tags=["Readability"])
 logger = logging.getLogger(__name__)
 
-router = APIRouter()
+def compute_readability(text: str) -> dict:
+    return {
+        "flesch_reading_ease": textstat.flesch_reading_ease(text),
+        "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
+        "gunning_fog_index": textstat.gunning_fog(text),
+        "smog_index": textstat.smog_index(text),
+        "coleman_liau_index": textstat.coleman_liau_index(text),
+        "automated_readability_index": textstat.automated_readability_index(text),
+    }
 
-class ReadabilityInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /readability_score endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/readability_score", dependencies=[Depends(verify_api_key)])
-def readability_score(payload: ReadabilityInput):
-    """
-    Calculates various readability scores for the provided text.
-
-    Args:
-        payload (ReadabilityInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing various readability scores.
-    """
-    text = payload.text
-    
+@router.post("/", dependencies=[Depends(verify_api_key)])
+async def readability_score(payload: TextOnlyRequest):
+    loop = asyncio.get_event_loop()
     try:
-        # Calculate different readability scores using textstat
-        flesch_reading_ease = textstat.flesch_reading_ease(text)
-        flesch_kincaid_grade = textstat.flesch_kincaid_grade(text)
-        gunning_fog = textstat.gunning_fog(text)
-        smog_index = textstat.smog_index(text)
-        coleman_liau_index = textstat.coleman_liau_index(text)
-        automated_readability_index = textstat.automated_readability_index(text)
-        
-        return {
-            "readability_scores": {
-                "flesch_reading_ease": flesch_reading_ease,
-                "flesch_kincaid_grade": flesch_kincaid_grade,
-                "gunning_fog_index": gunning_fog,
-                "smog_index": smog_index,
-                "coleman_liau_index": coleman_liau_index,
-                "automated_readability_index": automated_readability_index
-            }
-        }
+        scores = await loop.run_in_executor(executor, compute_readability, payload.text.strip())
+        return {"readability_scores": scores}
     except Exception as e:
-        logger.error(f"Error in readability_score: {e}", exc_info=True)
+        logger.error(f"Readability score error: {e}", exc_info=True)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during readability score calculation: {e}"
-        )
+            detail="An error occurred while computing readability scores."
+        )

app/routers/rewrite.py

@@ -0,0 +1,18 @@
+# routers/rewrite.py
+
+from fastapi import APIRouter, Depends
+from app.schemas.base import RewriteRequest
+from app.services.gpt4_rewrite import GPT4Rewriter
+from app.core.security import verify_api_key
+
+router = APIRouter(prefix="/rewrite", tags=["Rewrite"])
+rewriter = GPT4Rewriter()
+
+@router.post("/", dependencies=[Depends(verify_api_key)])
+def rewrite_with_instruction(payload: RewriteRequest):
+    result = rewriter.rewrite(
+        text=payload.text,
+        instruction=payload.instruction,
+        user_api_key=payload.user_api_key
+    )
+    return {"result": result}

app/routers/sentence_correctness.py

@@ -1,62 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app.core.security import verify_api_key
-import language_tool_python
-import logging # Import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-# Initialize LanguageTool. This will be the same instance as used for punctuation.
-# Ensure Java is installed in your environment.
-try:
-    tool = language_tool_python.LanguageTool('en-US')
-except Exception as e:
-    logger.error(f"Failed to initialize LanguageTool for sentence correctness: {e}", exc_info=True)
-    tool = None
-
-class SentenceCorrectnessInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /sentence_correctness endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/sentence_correctness", dependencies=[Depends(verify_api_key)])
-def sentence_correctness_check(payload: SentenceCorrectnessInput):
-    """
-    Provides feedback on sentence-level correctness (e.g., fragments, subject-verb agreement).
-
-    Args:
-        payload (SentenceCorrectnessInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing a list of sentence correctness feedback.
-    """
-    if tool is None:
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Sentence correctness service is not available (LanguageTool failed to initialize)."
-        )
-
-    text = payload.text
-    
-    try:
-        matches = tool.check(text)
-        
-        sentence_correctness_feedback = []
-        for m in matches:
-            # Exclude punctuation issues, as they are handled in a separate endpoint
-            if 'PUNCTUATION' not in m.ruleId.upper():
-                sentence_correctness_feedback.append(m.message)
-                
-        return {
-            "sentence_correctness": sentence_correctness_feedback
-        }
-    except Exception as e:
-        logger.error(f"Error in sentence_correctness_check: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during sentence correctness checking: {e}"
-        )

app/routers/summarize.py

@@ -1,39 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
-from app.core.security import verify_api_key
-import logging # Import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-class SummarizeInput(BaseModel): # Renamed Input to SummarizeInput for clarity
-    """
-    Pydantic BaseModel for validating the input request body for the /summarize endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/summarize", dependencies=[Depends(verify_api_key)])
-def summarize(payload: SummarizeInput): # Renamed input to payload for consistency
-    """
-    Summarizes the provided text.
-
-    Args:
-        payload (SummarizeInput): The request body containing the text to be summarized.
-
-    Returns:
-        dict: A dictionary containing the summarized text.
-    """
-    text = payload.text
-    
-    try:
-        summarized_text = models.run_flan_prompt(prompts.summarize_prompt(text))
-        return {"result": summarized_text}
-    except Exception as e:
-        logger.error(f"Error in summarize: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during summarization: {e}"
-        )

app/routers/tone.py

@@ -1,56 +1,11 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
+from fastapi import APIRouter, Depends
+from app.schemas.base import TextOnlyRequest
+from app.services.tone_classification import ToneClassifier
 from app.core.security import verify_api_key
-import logging # Import logging
 
-logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/tone", tags=["Tone"])
+classifier = ToneClassifier()
 
-router = APIRouter()
-
-class ToneInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /tone_analysis endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/tone_analysis", dependencies=[Depends(verify_api_key)])
-def tone_analysis(payload: ToneInput):
-    """
-    Analyzes the tone of the provided text and suggests improvements.
-
-    Args:
-        payload (ToneInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing the detected tone and a suggestion.
-    """
-    text = payload.text
-    
-    try:
-        detected_tone = models.classify_tone(text)
-        
-        tone_suggestion_text = ""
-        # Provide a simple tone suggestion based on the detected tone.
-        # This logic can be expanded for more sophisticated suggestions based on context or user goals.
-        if detected_tone in ["neutral", "joy", "sadness", "anger", "fear", "disgust", "surprise"]:
-            if detected_tone in ["neutral", "joy"]:
-                tone_suggestion_text = models.run_flan_prompt(prompts.tone_prompt(text, "formal"))
-            else: # For emotions like anger, sadness, fear, etc., suggest a more neutral/calm tone
-                tone_suggestion_text = models.run_flan_prompt(prompts.tone_prompt(text, "neutral and calm"))
-        else:
-            tone_suggestion_text = f"The detected tone '{detected_tone}' seems appropriate for general communication."
-
-        return {
-            "tone_analysis": {
-                "detected": detected_tone,
-                "suggestion": tone_suggestion_text
-            }
-        }
-    except Exception as e:
-        logger.error(f"Error in tone_analysis: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during tone analysis: {e}"
-        )
+@router.post("/", dependencies=[Depends(verify_api_key)])
+def classify_tone(payload: TextOnlyRequest):
+    return {"result": classifier.classify(payload.text)}

app/routers/translate.py

@@ -1,41 +1,15 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models
+from fastapi import APIRouter, Depends
+from app.schemas.base import TranslateRequest
+from app.services.translation import Translator
 from app.core.security import verify_api_key
-import logging # Import logging
 
-logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/translate", tags=["Translate"])
+translator = Translator()
 
-router = APIRouter()
-
-class TranslateInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /translate endpoint.
-    It expects two fields: 'text' (string) and 'target_lang' (string).
-    """
-    text: str
-    target_lang: str
-
-@router.post("/translate", dependencies=[Depends(verify_api_key)])
-def translate(payload: TranslateInput): # Renamed input to payload for consistency
-    """
-    Translates the provided text to a target language.
-
-    Args:
-        payload (TranslateInput): The request body containing the text and target language.
-
-    Returns:
-        dict: A dictionary containing the translated text.
-    """
-    text = payload.text
-    target_lang = payload.target_lang
-    
-    try:
-        translated_text = models.run_translation(text, target_lang)
-        return {"result": translated_text}
-    except Exception as e:
-        logger.error(f"Error in translate: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during translation: {e}"
-        )
+@router.post("/to", dependencies=[Depends(verify_api_key)])
+def translate_text(payload: TranslateRequest):
+    result = translator.translate(
+        text=payload.text,
+        target_lang=payload.target_lang
+    )
+    return {"result": result}

app/routers/vocabulary.py

@@ -1,42 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
-from app.core.security import verify_api_key
-import logging # Import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-class VocabularyInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /vocabulary_suggestions endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/vocabulary_suggestions", dependencies=[Depends(verify_api_key)])
-def vocabulary_suggestions(payload: VocabularyInput):
-    """
-    Provides suggestions for vocabulary improvement (e.g., stronger synonyms).
-
-    Args:
-        payload (VocabularyInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing vocabulary suggestions.
-    """
-    text = payload.text
-    
-    try:
-        suggestions_raw = models.run_flan_prompt(prompts.vocabulary_prompt(text))
-        
-        return {
-            "vocabulary_suggestions": suggestions_raw
-        }
-    except Exception as e:
-        logger.error(f"Error in vocabulary_suggestions: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during vocabulary suggestion: {e}"
-        )

app/routers/voice.py

@@ -1,72 +1,11 @@
-from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
-from pydantic import BaseModel
-from app import models, prompts
+from fastapi import APIRouter, Depends
+from app.schemas.base import TextOnlyRequest
+from app.services.voice_detection import VoiceDetector
 from app.core.security import verify_api_key
-import spacy
-import logging # Import logging
 
-logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/voice", tags=["Voice"])
+detector = VoiceDetector()
 
-router = APIRouter()
-
-# Load the spaCy English language model.
-try:
-    nlp = spacy.load("en_core_web_sm")
-except OSError as e:
-    logger.error(f"SpaCy model 'en_core_web_sm' not found. Please run: python -m spacy download en_core_web_sm. Error: {e}", exc_info=True)
-    nlp = None # Set to None if initialization fails
-    # Re-raising here to prevent server startup if critical dependency is missing
-    raise RuntimeError("SpaCy model 'en_core_web_sm' not loaded. Please install it.")
-
-
-class VoiceInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /voice_analysis endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-@router.post("/voice_analysis", dependencies=[Depends(verify_api_key)])
-def voice_analysis(payload: VoiceInput):
-    """
-    Detects active/passive voice and suggests improvements.
-
-    Args:
-        payload (VoiceInput): The request body containing the text to be analyzed.
-
-    Returns:
-        dict: A dictionary containing the detected voice and a suggestion.
-    """
-    if nlp is None:
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Voice analysis service is not available (SpaCy model failed to load)."
-        )
-
-    text = payload.text
-    
-    try:
-        doc = nlp(text)
-        
-        voice_detected = "active"
-        voice_suggestion = "None \u2014 active voice is fine here."
-    
-        for token in doc:
-            if token.dep_ == "auxpass":
-                voice_detected = "passive"
-                better_voice_prompt = prompts.active_voice_prompt(text)
-                voice_suggestion = models.run_flan_prompt(better_voice_prompt)
-                break
-    
-        return {
-            "voice": {
-                "detected": voice_detected,
-                "suggestion": voice_suggestion
-            }
-        }
-    except Exception as e:
-        logger.error(f"Error in voice_analysis: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"An error occurred during voice analysis: {e}"
-        )
+@router.post("/", dependencies=[Depends(verify_api_key)])
+def detect_voice(payload: TextOnlyRequest):
+    return {"result": detector.classify(payload.text)}

app/schemas/base.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field
+
+class TextOnlyRequest(BaseModel):
+    text: str = Field(..., example="Your input text here")
+
+class RewriteRequest(BaseModel):
+    text: str = Field(..., example="Your input text here")
+    instruction: str = Field(..., example="Rewrite this more concisely")
+    user_api_key: str = Field(..., example="sk-...")
+
+class TranslateRequest(BaseModel):
+    text: str = Field(..., example="Translate this")
+    target_lang: str = Field(..., example="fr")

app/services/base.py

@@ -0,0 +1,42 @@
+import torch
+from threading import Lock
+import logging
+import time
+logger = logging.getLogger(__name__)
+
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logging.getLogger(__name__).info(f"Using device: {DEVICE}")
+
+_models = {}
+_models_lock = Lock()
+
+
+def get_cached_model(model_name: str, load_fn):
+    with _models_lock:
+        if model_name not in _models:
+            logging.info(f"Loading model: {model_name}")
+            _models[model_name] = load_fn()
+        return _models[model_name]
+
+
+def load_with_timer(name, fn):
+    # TODO: Add timing later if needed
+    return fn()
+
+def timed_model_load(label: str, load_fn):
+    start = time.time()
+    model = load_fn()
+    logger.info(f"{label} loaded in {time.time() - start:.2f}s")
+    return model
+
+# Lazy spaCy loading
+_nlp = None
+
+def get_spacy():
+    global _nlp
+    if _nlp is None:
+        import spacy
+        _nlp = spacy.load("en_core_web_sm")
+    return _nlp
+

app/services/conciseness_suggestion.py

@@ -0,0 +1,30 @@
+import logging
+from app.services.gpt4_rewrite import GPT4Rewriter 
+from app.core.prompts import concise_prompt
+
+logger = logging.getLogger(__name__)
+gpt4_rewriter = GPT4Rewriter()
+
+class ConcisenessSuggester:
+    def suggest(self, text: str, user_api_key: str) -> str:
+        text = text.strip()
+        if not text:
+            logger.warning("Conciseness suggestion requested for empty input.")
+            return "Input text is empty."
+
+        if not user_api_key:
+            logger.error("Conciseness suggestion failed: Missing user_api_key.")
+            return "Missing OpenAI API key."
+
+        instruction = concise_prompt(text)
+        concise_text = gpt4_rewriter.rewrite(text, user_api_key, instruction)
+
+        if concise_text.startswith("An OpenAI API error occurred:") or \
+           concise_text.startswith("An unexpected error occurred:") or \
+           concise_text.startswith("Missing OpenAI API key.") or \
+           concise_text.startswith("Input text is empty."):
+            logger.error(f"GPT-4 conciseness suggestion failed for text: '{text[:50]}...' - {concise_text}")
+            return concise_text
+
+        logger.info(f"Conciseness suggestion completed for text length: {len(text)}")
+        return concise_text

app/services/gpt4_rewrite.py

@@ -0,0 +1,44 @@
+import openai
+import logging
+from tenacity import retry, stop_after_attempt, wait_exponential
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+class GPT4Rewriter:
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def rewrite(self, text: str, user_api_key: str, instruction: str) -> str:
+        if not user_api_key:
+            logger.error("GPT-4 rewrite requested without an OpenAI API key.")
+            return "Missing OpenAI API key."
+
+        text = text.strip()
+        instruction = instruction.strip()
+
+        if not text:
+            logger.warning("GPT-4 rewrite requested for empty input.")
+            return "Input text is empty."
+        if not instruction:
+            logger.error("GPT-4 rewrite requested without a specific instruction.")
+            return "Missing rewrite instruction. Please provide a clear instruction for the rewrite."
+
+        messages = [
+            {"role": "system", "content": instruction},
+            {"role": "user", "content": text},
+        ]
+
+        try:
+            client = openai.OpenAI(api_key=user_api_key)
+            response = client.chat.completions.create(
+                model=settings.openai_model,
+                messages=messages,
+                temperature=settings.openai_temperature,
+                max_tokens=settings.openai_max_tokens
+            )
+            return response.choices[0].message.content.strip()
+        except openai.APIError as e:
+            logger.error(f"OpenAI API error during GPT-4 rewrite: {e}")
+            return f"An OpenAI API error occurred: {e}"
+        except Exception as e:
+            logger.error(f"Unexpected error during GPT-4 rewrite: {e}")
+            return "An unexpected error occurred during GPT-4 rewrite."

app/services/grammar.py

@@ -0,0 +1,32 @@
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import torch
+from .base import get_cached_model, DEVICE, load_with_timer
+import logging
+
+class GrammarCorrector:
+    def __init__(self):
+        self.tokenizer, self.model = self._load_model()
+
+    def _load_model(self):
+        def load_fn():
+            tokenizer = load_with_timer("grammar_tokenizer", lambda: AutoTokenizer.from_pretrained("visheratin/t5-efficient-mini-grammar-correction"))
+            model = load_with_timer("grammar_model", lambda: AutoModelForSeq2SeqLM.from_pretrained("visheratin/t5-efficient-mini-grammar-correction"))
+            model = model.to(DEVICE).eval()
+            return tokenizer, model
+
+        return get_cached_model("grammar", load_fn)
+
+    def correct(self, text: str) -> str:
+        text = text.strip()
+        if not text:
+            logging.warning("Grammar correction requested for empty input.")
+            return "Input text is empty."
+
+        try:
+            with torch.no_grad():
+                inputs = self.tokenizer([text], return_tensors="pt", truncation=True, padding=True).to(DEVICE)
+                outputs = self.model.generate(**inputs, max_length=256, num_beams=4, early_stopping=True)
+                return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        except Exception as e:
+            logging.error(f"Error during grammar correction: {e}")
+            return "An error occurred during grammar correction."

app/services/inclusive_language.py

@@ -0,0 +1,98 @@
+import yaml
+from pathlib import Path
+from spacy.matcher import PhraseMatcher
+from typing import List, Dict
+from .base import get_spacy
+from app.core.config import settings
+import logging
+
+class InclusiveLanguageChecker:
+    def __init__(self, rules_directory=settings.inclusive_rules_dir):
+        self.matcher = PhraseMatcher(get_spacy().vocab, attr="LOWER")
+        self.rules = self._load_inclusive_rules(rules_directory)
+        self._init_matcher()
+
+    def _load_inclusive_rules(self, directory: str) -> Dict[str, Dict]:
+        rules = {}
+        for path in Path(directory).glob("*.yml"):
+            try:
+                with open(path, encoding="utf-8") as f:
+                    rule_list = yaml.safe_load(f)
+                    if not isinstance(rule_list, list):
+                        logging.warning(f"Skipping malformed rule file: {path}")
+                        continue
+                    for rule in rule_list:
+                        note = rule.get("note", "")
+                        source = rule.get("source", "")
+                        considerate = rule.get("considerate", [])
+                        inconsiderate = rule.get("inconsiderate", [])
+
+                        if isinstance(considerate, str):
+                            considerate = [considerate]
+                        if isinstance(inconsiderate, str):
+                            inconsiderate = [inconsiderate]
+
+                        for phrase in inconsiderate:
+                            key = phrase.lower()
+                            rules[key] = {
+                                "note": note,
+                                "considerate": considerate,
+                                "source": source,
+                                "type": rule.get("type", "basic")
+                            }
+            except Exception as e:
+                logging.error(f"Error loading inclusive language rule from {path}: {e}")
+        return rules
+
+    def _init_matcher(self):
+        for phrase in self.rules:
+            self.matcher.add(phrase, [get_spacy().make_doc(phrase)])
+        logging.info(f"Loaded {len(self.rules)} inclusive language rules.")
+
+    def check(self, text: str) -> List[Dict]:
+        text = text.strip()
+        if not text:
+            logging.warning("Inclusive language check requested for empty input.")
+            return []
+
+        nlp = get_spacy()
+        doc = nlp(text)
+        matches = self.matcher(doc)
+        results = []
+        matched_spans = set()
+
+        # 1. PhraseMatcher (exact) matches
+        for match_id, start, end in matches:
+            phrase_str = nlp.vocab.strings[match_id]
+            matched_spans.add((start, end))
+            rule = self.rules.get(phrase_str.lower())
+            if rule:
+                results.append({
+                    "term": doc[start:end].text,
+                    "type": rule["type"],
+                    "note": rule["note"],
+                    "suggestions": rule["considerate"],
+                    "context": doc[start:end].sent.text,
+                    "start": doc[start].idx,
+                    "end": doc[end - 1].idx + len(doc[end - 1]),
+                    "source": rule.get("source", "")
+                })
+
+        # 2. Lemma-based fallback (for plural/inflected forms)
+        for token in doc:
+            lemma = token.lemma_.lower()
+            span_key = (token.i, token.i + 1)
+            if lemma in self.rules and span_key not in matched_spans:
+                rule = self.rules[lemma]
+                results.append({
+                    "term": token.text,
+                    "type": rule["type"],
+                    "note": rule["note"],
+                    "suggestions": rule["considerate"],
+                    "context": token.sent.text,
+                    "start": token.idx,
+                    "end": token.idx + len(token),
+                    "source": rule.get("source", "")
+                })
+
+        return results

app/services/paraphrase.py

@@ -0,0 +1,39 @@
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import torch
+from .base import get_cached_model, DEVICE, timed_model_load
+import logging
+
+class Paraphraser:
+    def __init__(self):
+        self.tokenizer, self.model = self._load_model()
+
+    def _load_model(self):
+        def load_fn():
+            tokenizer = timed_model_load("paraphrase_tokenizer", lambda: AutoTokenizer.from_pretrained("humarin/chatgpt_paraphraser_on_T5_base"))
+            model = timed_model_load("paraphrase_model", lambda: AutoModelForSeq2SeqLM.from_pretrained("humarin/chatgpt_paraphraser_on_T5_base"))
+            model = model.to(DEVICE).eval()
+            return tokenizer, model
+        return get_cached_model("paraphrase", load_fn)
+
+    def paraphrase(self, text: str) -> str:
+        text = text.strip()
+        if not text:
+            logging.warning("Paraphrasing requested for empty input.")
+            return "Input text is empty."
+
+        prompt = f"paraphrase: {text} </s>"
+        try:
+            with torch.no_grad():
+                inputs = self.tokenizer([prompt], return_tensors="pt", padding=True, truncation=True).to(DEVICE)
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=256,
+                    num_beams=5,
+                    num_return_sequences=1,
+                    early_stopping=True
+                )
+                return self.tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)
+        except Exception as e:
+            logging.error(f"Error during paraphrasing: {e}")
+            return f"An error occurred during paraphrasing: {e}"
+

app/services/tone_classification.py

@@ -0,0 +1,36 @@
+from transformers import pipeline
+import torch
+from .base import get_cached_model, DEVICE
+import logging
+
+class ToneClassifier:
+    def __init__(self):
+        self.classifier = self._load_model()
+
+    def _load_model(self):
+        def load_fn():
+            return pipeline(
+                "sentiment-analysis",
+                model="j-hartmann/emotion-english-distilroberta-base",
+                top_k=1,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        return get_cached_model("tone", load_fn)
+
+    def classify(self, text: str) -> str:
+        text = text.strip()
+        if not text:
+            logging.warning("Tone classification requested for empty input.")
+            return "Input text is empty."
+
+        try:
+            result = self.classifier(text)
+            if isinstance(result, list):
+                if isinstance(result[0], list):
+                    result = result[0]
+                if result:
+                    return result[0]['label']
+            return "Unknown"
+        except Exception as e:
+            logging.error(f"Error during tone classification: {e}")
+            return "An error occurred during tone classification."

app/services/translation.py

@@ -0,0 +1,40 @@
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import torch
+import logging
+from .base import get_cached_model, DEVICE, timed_model_load
+from app.core.config import settings
+
+class Translator:
+    def __init__(self):
+        self.tokenizer, self.model = self._load_model()
+
+    def _load_model(self):
+        def load_fn():
+            tokenizer = timed_model_load("translate_tokenizer", lambda: AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-ROMANCE"))
+            model = timed_model_load("translate_model", lambda: AutoModelForSeq2SeqLM.from_pretrained("Helsinki-NLP/opus-mt-en-ROMANCE"))
+            model = model.to(DEVICE).eval()
+            return tokenizer, model
+        return get_cached_model("translate", load_fn)
+
+    def translate(self, text: str, target_lang: str) -> str:
+        text = text.strip()
+        target_lang = target_lang.strip()
+
+        if not text:
+            logging.warning("Translation requested for empty input.")
+            return "Input text is empty."
+        if not target_lang:
+            logging.warning("Translation requested without a target language.")
+            return "Target language is empty."
+        if target_lang not in settings.supported_translation_languages:
+            return f"Unsupported target language: {target_lang}"
+
+        prompt = f">>{target_lang}<< {text}"
+        try:
+            with torch.no_grad():
+                inputs = self.tokenizer([prompt], return_tensors="pt", truncation=True, padding=True).to(DEVICE)
+                outputs = self.model.generate(**inputs, max_length=256, num_beams=1, early_stopping=True)
+                return self.tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)
+        except Exception as e:
+            logging.error(f"Error during translation: {e}")
+            return f"An error occurred during translation: {e}"

app/services/vocabulary_enhancement.py

@@ -0,0 +1,30 @@
+import logging
+from app.services.gpt4_rewrite import GPT4Rewriter
+from app.core.prompts import vocabulary_prompt
+
+logger = logging.getLogger(__name__)
+gpt4_rewriter = GPT4Rewriter()
+
+class VocabularyEnhancer:
+    def enhance(self, text: str, user_api_key: str) -> str:
+        text = text.strip()
+        if not text:
+            logger.warning("Vocabulary enhancement requested for empty input.")
+            return "Input text is empty."
+
+        if not user_api_key:
+            logger.error("Vocabulary enhancement failed: Missing user_api_key.")
+            return "Missing OpenAI API key."
+
+        instruction = vocabulary_prompt(text)
+        enhanced_text = gpt4_rewriter.rewrite(text, user_api_key, instruction)
+
+        if enhanced_text.startswith("An OpenAI API error occurred:") or \
+           enhanced_text.startswith("An unexpected error occurred:") or \
+           enhanced_text.startswith("Missing OpenAI API key.") or \
+           enhanced_text.startswith("Input text is empty."):
+            logger.error(f"GPT-4 vocabulary enhancement failed for text: '{text[:50]}...' - {enhanced_text}")
+            return enhanced_text
+
+        logger.info(f"Vocabulary enhancement completed for text length: {len(text)}")
+        return enhanced_text

app/services/voice_detection.py

@@ -0,0 +1,33 @@
+import logging
+from .base import get_spacy
+
+class VoiceDetector:
+    def __init__(self):
+        self.nlp = get_spacy()
+
+    def classify(self, text: str) -> str:
+        text = text.strip()
+        if not text:
+            logging.warning("Voice detection requested for empty input.")
+            return "Input text is empty."
+
+        try:
+            doc = self.nlp(text)
+            passive_sentences = 0
+            total_sentences = 0
+
+            for sent in doc.sents:
+                total_sentences += 1
+                for token in sent:
+                    if token.dep_ == "nsubjpass":
+                        passive_sentences += 1
+                        break
+
+            if total_sentences == 0:
+                return "Unknown"
+
+            ratio = passive_sentences / total_sentences
+            return "Passive" if ratio > 0.5 else "Active"
+        except Exception as e:
+            logging.error(f"Error during voice detection: {e}")
+            return "An error occurred during voice detection."

app/test/test_rewrite.py

@@ -0,0 +1,15 @@
+import pytest
+from fastapi.testclient import TestClient
+from main import create_app
+
+client = TestClient(create_app())
+
+def test_rewrite_success():
+    payload = {
+        "text": "This is a very long and unnecessarily wordy sentence that could be simpler.",
+        "instruction": "Make this more concise"
+    }
+    headers = {"x-api-key": "your-secret-key"}
+    response = client.post("/rewrite/", json=payload, headers=headers)
+    assert response.status_code == 200
+    assert "result" in response.json()

app/test_main.py

@@ -1,39 +0,0 @@
-from fastapi.testclient import TestClient
-from app.main import app
-
-client = TestClient(app)
-
-def test_grammar():
-    response = client.post("/rewrite", json={"text": "She go to school yesterday.", "mode": "grammar"})
-    assert response.status_code == 200
-    assert "result" in response.json()
-
-def test_paraphrase():
-    response = client.post("/rewrite", json={"text": "I love programming.", "mode": "paraphrase"})
-    assert response.status_code == 200
-    assert "result" in response.json()
-
-def test_clarity():
-    response = client.post("/rewrite", json={"text": "This sentence is a bit confusing.", "mode": "clarity"})
-    assert response.status_code == 200
-    assert "result" in response.json()
-
-def test_fluency():
-    response = client.post("/rewrite", json={"text": "He no went there before.", "mode": "fluency"})
-    assert response.status_code == 200
-    assert "result" in response.json()
-
-def test_tone():
-    response = client.post("/rewrite", json={"text": "Leave me alone.", "mode": "tone", "tone": "friendly"})
-    assert response.status_code == 200
-    assert "result" in response.json()
-
-def test_translation():
-    response = client.post("/rewrite", json={"text": "How are you?", "mode": "translate", "target_lang": "fr"})
-    assert response.status_code == 200
-    assert "result" in response.json()
-
-def test_pronoun():
-    response = client.post("/rewrite", json={"text": "Each user must provide his email.", "mode": "pronoun"})
-    assert response.status_code == 200
-    assert "result" in response.json()

app/utils/shared.py

@@ -0,0 +1,4 @@
+from concurrent.futures import ThreadPoolExecutor
+
+# Shared executor for all CPU-bound tasks
+executor = ThreadPoolExecutor(max_workers=4)

requirements.txt

@@ -6,6 +6,6 @@ sentencepiece
 pyspellchecker
 spacy
 nltk
-language-tool-python
 scikit-learn
 textstat
+numpy>=1.21

run.py

@@ -0,0 +1,15 @@
+# run.py (no change needed for path handling if app.main:app is used)
+import uvicorn
+import os
+import sys
+# from pathlib import Path # No longer strictly necessary to add project_root to sys.path explicitly here
+# sys.path.insert(0, str(project_root)) # Can likely remove this line if your only problem was 'models' import
+
+host = "0.0.0.0"
+port = 7860
+app_module = "app.main:app" # This refers to the 'app' package correctly
+
+if __name__ == "__main__":
+    print(f"Starting Uvicorn server for {app_module} at http://{host}:{port}")
+    # ... rest of your print statements and uvicorn.run call
+    uvicorn.run(app_module, host=host, port=port, reload=True)