feat: add backend endpoint /thesaurus-wordsapi with related add functions (mongodb persistence)

my_ghost_writer/app.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 from datetime import datetime
 from http.client import HTTPException
@@ -10,15 +11,38 @@ from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
+from pymongo import __version__ as pymongo_version
+from pymongo.errors import PyMongoError
 
-from my_ghost_writer.constants import (ALLOWED_ORIGIN_LIST, API_MODE, DOMAIN, IS_TESTING, LOG_LEVEL, PORT, STATIC_FOLDER,
-    WORDSAPI_KEY, WORDSAPI_URL, app_logger, RAPIDAPI_HOST)
-from my_ghost_writer.thesaurus import get_document_by_word, insert_document
+from my_ghost_writer import pymongo_operations_rw
+from my_ghost_writer.constants import (app_logger, ALLOWED_ORIGIN_LIST, API_MODE, DOMAIN, IS_TESTING, LOG_LEVEL, PORT,
+    STATIC_FOLDER, WORDSAPI_KEY, WORDSAPI_URL, RAPIDAPI_HOST, MONGO_USE_OK, MONGO_HEALTHCHECK_SLEEP)
+from my_ghost_writer.pymongo_utils import mongodb_health_check
 from my_ghost_writer.type_hints import RequestTextFrequencyBody, RequestQueryThesaurusWordsapiBody
 
 
+async def mongo_health_check_background_task():
+    app_logger.info(f"starting task, MONGO_USE_OK:{MONGO_USE_OK}...")
+    while MONGO_USE_OK:
+        try:
+            db_ok["mongo_ok"] = health_mongo() == "Mongodb: still alive..."
+        except PyMongoError:
+            db_ok["mongo_ok"] = False
+        await asyncio.sleep(MONGO_HEALTHCHECK_SLEEP)
+
+
+async def lifespan(app: FastAPI):
+    task = asyncio.create_task(mongo_health_check_background_task())
+    yield
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+
+
 fastapi_title = "My Ghost Writer"
-app = FastAPI(title=fastapi_title, version="1.0")
+app = FastAPI(title=fastapi_title, version="1.0", lifespan=lifespan)
 app_logger.info(f"allowed_origins:{ALLOWED_ORIGIN_LIST}, IS_TESTING:{IS_TESTING}, LOG_LEVEL:{LOG_LEVEL}!")
 app.add_middleware(
     CORSMiddleware,
@@ -26,6 +50,7 @@ app.add_middleware(
     allow_credentials=True,
     allow_methods=["GET", "POST"]
 )
+db_ok = {"mongo_ok": MONGO_USE_OK}
 
 
 @app.middleware("http")
@@ -40,10 +65,25 @@ def health():
     from nltk import __version__ as nltk_version
     from fastapi import __version__ as fastapi_version
     from my_ghost_writer.__version__ import __version__ as ghost_writer_version
-    app_logger.info(f"still alive... FastAPI version:{fastapi_version}, nltk version:{nltk_version}, my-ghost-writer version:{ghost_writer_version}!")
+    app_logger.info(
+        f"still alive... FastAPI version:{fastapi_version}, nltk version:{nltk_version}, my-ghost-writer version:{ghost_writer_version}!")
     return "Still alive..."
 
 
+@app.get("/health-mongo")
+def health_mongo() -> str:
+    app_logger.info(f"pymongo driver version:{pymongo_version}!")
+    if MONGO_USE_OK:
+        try:
+            db_ok["mongo_ok"] = mongodb_health_check()
+            return "Mongodb: still alive..."
+        except PyMongoError as pme:
+            app_logger.error(str(pme))
+            db_ok["mongo_ok"] = False
+            raise HTTPException("mongo not ok!")
+    return f"MONGO_USE_OK:{MONGO_USE_OK}..."
+
+
 @app.post("/words-frequency")
 def get_words_frequency(body: RequestTextFrequencyBody | str) -> JSONResponse:
     from my_ghost_writer.text_parsers import text_stemming
@@ -73,42 +113,49 @@ def get_thesaurus_wordsapi(body: RequestQueryThesaurusWordsapiBody | str) -> JSO
     app_logger.info(f"body type: {type(body)} => {body}.")
     body_validated = RequestQueryThesaurusWordsapiBody.model_validate_json(body)
     query = body_validated.query
-    try:
-        response = get_document_by_word(query=query)
-        t1 = datetime.now()
-        duration = (t1 - t0).total_seconds()
-        app_logger.info(f"found local data, duration: {duration:.3f}s.")
-        return JSONResponse(status_code=200, content={"duration": duration, "thesaurus": response, "source": "local"})
-    except Exception as e:
-        app_logger.info(f"e:{e}, document not found?")
-        url = f"{WORDSAPI_URL}/{query}"
-        app_logger.info(f"url: {type(url)} => {url}.")
-        headers = {
-            "x-rapidapi-key": WORDSAPI_KEY,
-            "x-rapidapi-host": RAPIDAPI_HOST
-        }
-        response = requests.get(url, headers=headers)
-        t1 = datetime.now()
-        duration = (t1 - t0).total_seconds()
-        app_logger.info(f"response.status_code: {response.status_code}, duration: {duration:.3f}s.")
-        msg = f"API response is not 200: '{response.status_code}', query={query}, url={url}, duration: {duration:.3f}s."
+    use_mongo: bool = db_ok["mongo_ok"]
+    app_logger.info(f"query: {type(query)} => {query}, use mongo? {use_mongo}.")
+    if use_mongo:
         try:
-            assert response.status_code == 200, msg
-            response_json = response.json()
-            insert_document(response_json)
+            response = pymongo_operations_rw.get_document_by_word(query=query)
+            t1 = datetime.now()
+            duration = (t1 - t0).total_seconds()
+            app_logger.info(f"found local data, duration: {duration:.3f}s.")
+            return JSONResponse(status_code=200, content={"duration": duration, "thesaurus": response, "source": "local"})
+        except (PyMongoError, AssertionError) as pme:
+            app_logger.info(f"{pme}! Let's try the remote service...")
+
+    url = f"{WORDSAPI_URL}/{query}"
+    app_logger.info(f"url: {type(url)} => {url}.")
+    headers = {
+        "x-rapidapi-key": WORDSAPI_KEY,
+        "x-rapidapi-host": RAPIDAPI_HOST
+    }
+    response = requests.get(url, headers=headers)
+    t1 = datetime.now()
+    duration = (t1 - t0).total_seconds()
+    app_logger.info(f"response.status_code: {response.status_code}, duration: {duration:.3f}s.")
+    msg = f"API response is not 200: '{response.status_code}', query={query}, url={url}, duration: {duration:.3f}s."
+    try:
+        assert response.status_code == 200, msg
+        response_json = response.json()
+        if use_mongo:
+            app_logger.debug(f"use_mongo:{use_mongo}, inserting response '{response_json}' by query '{query}' on db...")
+            pymongo_operations_rw.insert_document(response_json)
             del response_json["_id"]  # since we inserted the wordsapi response on mongodb now it have a bson _id object not serializable by default
-            t2 = datetime.now()
-            duration = (t2 - t1).total_seconds()
-            app_logger.info(f"response_json: inserted json on local db, duration: {duration:.3f}s. ...")
-            return JSONResponse(status_code=200, content={"duration": duration, "thesaurus": response_json, "source": "wordsapi"})
-        except AssertionError as ae:
-            app_logger.error(f"URL: query => {type(query)} {query}; url => {type(url)} {url}.")
-            app_logger.error(f"headers type: {type(headers)}...")
-            # app_logger.error(f"headers: {headers}...")
-            app_logger.error("response:")
-            app_logger.error(str(response))
-            app_logger.error(str(ae))
-            raise HTTPException(ae)
+        t2 = datetime.now()
+        duration = (t2 - t1).total_seconds()
+        app_logger.info(f"response_json: inserted json on local db, duration: {duration:.3f}s. ...")
+        return JSONResponse(status_code=200,
+                            content={"duration": duration, "thesaurus": response_json, "source": "wordsapi"})
+    except AssertionError as ae:
+        app_logger.error(f"URL: query => {type(query)} {query}; url => {type(url)} {url}.")
+        app_logger.error(f"headers type: {type(headers)}...")
+        # app_logger.error(f"headers: {headers}...")
+        app_logger.error("response:")
+        app_logger.error(str(response))
+        app_logger.error(str(ae))
+        raise HTTPException(ae)
 
 
 @app.exception_handler(RequestValidationError)
@@ -128,7 +175,8 @@ def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse
 try:
     app.mount("/static", StaticFiles(directory=STATIC_FOLDER, html=True), name="static")
 except Exception as ex_mount_static:
-    app_logger.error(f"Failed to mount static folder: {STATIC_FOLDER}, exception: {ex_mount_static}, API_MODE: {API_MODE}!")
+    app_logger.error(
+        f"Failed to mount static folder: {STATIC_FOLDER}, exception: {ex_mount_static}, API_MODE: {API_MODE}!")
     if not API_MODE:
         app_logger.exception(f"since API_MODE is {API_MODE} we will raise the exception!")
         raise ex_mount_static
@@ -136,7 +184,6 @@ except Exception as ex_mount_static:
 # add the CorrelationIdMiddleware AFTER the @app.middleware("http") decorated function to avoid missing request id
 app.add_middleware(CorrelationIdMiddleware)
 
-
 try:
     @app.get("/")
     @app.get("/static/")
@@ -151,7 +198,8 @@ except Exception as ex_route_main:
 
 if __name__ == "__main__":
     try:
-        app_logger.info(f"Starting fastapi/gradio application {fastapi_title}, run in api mode: {API_MODE} (no static folder and main route)...")
+        app_logger.info(
+            f"Starting fastapi/gradio application {fastapi_title}, run in api mode: {API_MODE} (no static folder and main route)...")
         uvicorn.run("my_ghost_writer.app:app", host=DOMAIN, port=PORT, reload=bool(IS_TESTING))
     except Exception as ex_run:
         print(f"fastapi/gradio application {fastapi_title}, exception:{ex_run}!")

my_ghost_writer/constants.py

@@ -21,8 +21,17 @@ N_WORDS_GRAM = int(os.getenv("N_WORDS_GRAM", 2))
 WORDSAPI_KEY = os.getenv("WORDSAPI_KEY")
 WORDSAPI_URL = os.getenv("WORDSAPI_URL", "https://wordsapiv1.p.rapidapi.com/words")
 RAPIDAPI_HOST = os.getenv("RAPIDAPI_HOST", "wordsapiv1.p.rapidapi.com")
-MONGO_CONNECTION_STRING = os.getenv("MONGO_CONNECTION_STRING", "mongodb://localhost:27017")
-MONGO_CONNECTION_TIMEOUT = int(os.getenv("MONGO_CONNECTION_TIMEOUT", 800))
+MONGO_USE_OK = bool(os.getenv("MONGO_USE_OK", ""))
+MONGO_CONNECTION_STRING_LOCAL = "mongodb://localhost:27017"
+MONGO_CONNECTION_STRING = os.getenv("MONGO_CONNECTION_STRING", MONGO_CONNECTION_STRING_LOCAL)
+MONGO_CONNECTION_TIMEOUT_LOCAL = int(os.getenv("MONGO_CONNECTION_TIMEOUT_LOCAL", 200))
+MONGO_CONNECTION_TIMEOUT_REMOTE = int(os.getenv("MONGO_CONNECTION_TIMEOUT_REMOTE", 3000))
+MONGO_CONNECTION_TIMEOUT = int(os.getenv(
+    "MONGO_CONNECTION_TIMEOUT",
+    MONGO_CONNECTION_TIMEOUT_LOCAL if MONGO_CONNECTION_STRING == MONGO_CONNECTION_STRING_LOCAL else MONGO_CONNECTION_TIMEOUT_REMOTE
+))
+MONGO_HEALTHCHECK_SLEEP = int(os.getenv("MONGO_HEALTHCHECK_SLEEP", 900))
+DEFAULT_DBNAME_THESAURUS = "thesaurus"
 DEFAULT_COLLECTION_THESAURUS =os.getenv("DEFAULT_COLLECTION_THESAURUS", "wordsapi")
 session_logger.setup_logging(json_logs=LOG_JSON_FORMAT, log_level=LOG_LEVEL)
 app_logger = structlog.stdlib.get_logger(__name__)

my_ghost_writer/pymongo_get_database.py

@@ -1,16 +0,0 @@
-from pymongo import MongoClient
-
-from my_ghost_writer.constants import MONGO_CONNECTION_STRING, DEFAULT_COLLECTION_THESAURUS, MONGO_CONNECTION_TIMEOUT
-
-
-def get_database(db_name: str):
-    # Create a connection using MongoClient. You can import MongoClient or use pymongo.MongoClient
-    client = MongoClient(MONGO_CONNECTION_STRING, timeoutMS=MONGO_CONNECTION_TIMEOUT)
-
-    # Create the database for our example (we will use the same database throughout the tutorial
-    return client[db_name]
-
-
-def get_thesaurus_collection(collection_name: str = DEFAULT_COLLECTION_THESAURUS):
-    dbname = get_database(db_name="thesaurus")
-    return dbname[collection_name]

my_ghost_writer/{thesaurus.py → pymongo_operations_rw.py}

@@ -1,22 +1,20 @@
-from datetime import time
 import json
-from time import sleep
-from bson import json_util
+from my_ghost_writer import pymongo_utils
 from my_ghost_writer.constants import app_logger
-from my_ghost_writer.pymongo_get_database import get_thesaurus_collection
 
 
 def get_document_by_word(query: str) -> dict:
-    collection = get_thesaurus_collection()
+    collection = pymongo_utils.get_thesaurus_collection()
     output: dict = collection.find_one({"word": query})
+    assert output, f"not found document with query '{query}'..."
     del output["_id"]
     return output
 
 
 def insert_document(document: dict) -> None:
-    collection = get_thesaurus_collection()
+    collection = pymongo_utils.get_thesaurus_collection()
     result = collection.insert_one(document)
-    print(result)
+    app_logger.info(f"result:{result}.")
     try:
         assert result.inserted_id
     except AssertionError:

my_ghost_writer/pymongo_utils.py

@@ -0,0 +1,33 @@
+from pymongo import MongoClient
+
+from my_ghost_writer.constants import DEFAULT_DBNAME_THESAURUS, MONGO_CONNECTION_STRING, DEFAULT_COLLECTION_THESAURUS, MONGO_CONNECTION_TIMEOUT, app_logger
+
+
+def get_client() -> MongoClient:
+    client = MongoClient(MONGO_CONNECTION_STRING, timeoutMS=MONGO_CONNECTION_TIMEOUT)
+    return client
+
+
+def get_database(db_name: str = DEFAULT_DBNAME_THESAURUS):
+    client = get_client()
+    return client[db_name]
+
+
+def get_thesaurus_collection(db_name: str = DEFAULT_DBNAME_THESAURUS, collection_name: str = DEFAULT_COLLECTION_THESAURUS):
+    dbname = get_database(db_name=db_name)
+    return dbname[collection_name]
+
+
+def mongodb_health_check(db_name: str = DEFAULT_DBNAME_THESAURUS, collection_name: str = DEFAULT_COLLECTION_THESAURUS) -> bool:
+    client = get_client()
+    # Check server is available
+    client.admin.command('ping', check=True)
+    server_info = client.server_info()
+    server_version = server_info["version"]
+    app_logger.info(f"mongodb server_version:{server_version}!")
+    # Try a simple find operation
+    db = client[db_name]
+    collection = db[collection_name]
+    collection.find_one()
+    app_logger.info("mongodb: still alive...")
+    return True

my_ghost_writer/type_hints.py

@@ -1,3 +1,4 @@
+from typing import TypedDict
 from pydantic import BaseModel
 
 
@@ -13,9 +14,6 @@ class RequestQueryThesaurusWordsapiBody(BaseModel):
     query: str
 
 
-from typing import TypedDict
-
-
 class InputTextRow(TypedDict):
     """
     TypedDict for input text row.

poetry.lock

@@ -18,7 +18,7 @@ version = "4.9.0"
 description = "High level compatibility layer for multiple asynchronous event loop implementations"
 optional = false
 python-versions = ">=3.9"
-groups = ["webserver"]
+groups = ["main", "test", "webserver"]
 files = [
     {file = "anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c"},
     {file = "anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028"},
@@ -54,6 +54,18 @@ starlette = ">=0.18"
 [package.extras]
 celery = ["celery"]
 
+[[package]]
+name = "certifi"
+version = "2025.6.15"
+description = "Python package for providing Mozilla's CA Bundle."
+optional = false
+python-versions = ">=3.7"
+groups = ["main", "test"]
+files = [
+    {file = "certifi-2025.6.15-py3-none-any.whl", hash = "sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057"},
+    {file = "certifi-2025.6.15.tar.gz", hash = "sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b"},
+]
+
 [[package]]
 name = "click"
 version = "8.1.8"
@@ -167,7 +179,7 @@ version = "2.7.0"
 description = "DNS toolkit"
 optional = false
 python-versions = ">=3.9"
-groups = ["main"]
+groups = ["test", "webserver"]
 files = [
     {file = "dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86"},
     {file = "dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1"},
@@ -188,7 +200,7 @@ version = "1.2.2"
 description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
-groups = ["test", "webserver"]
+groups = ["main", "test", "webserver"]
 markers = "python_version == \"3.10\""
 files = [
     {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
@@ -225,19 +237,66 @@ version = "0.14.0"
 description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
 optional = false
 python-versions = ">=3.7"
-groups = ["webserver"]
+groups = ["main", "test", "webserver"]
 files = [
     {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"},
     {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"},
 ]
 
+[[package]]
+name = "httpcore"
+version = "1.0.8"
+description = "A minimal low-level HTTP client."
+optional = false
+python-versions = ">=3.8"
+groups = ["main", "test"]
+files = [
+    {file = "httpcore-1.0.8-py3-none-any.whl", hash = "sha256:5254cf149bcb5f75e9d1b2b9f729ea4a4b883d1ad7379fc632b727cec23674be"},
+    {file = "httpcore-1.0.8.tar.gz", hash = "sha256:86e94505ed24ea06514883fd44d2bc02d90e77e7979c8eb71b90f41d364a1bad"},
+]
+
+[package.dependencies]
+certifi = "*"
+h11 = ">=0.13,<0.15"
+
+[package.extras]
+asyncio = ["anyio (>=4.0,<5.0)"]
+http2 = ["h2 (>=3,<5)"]
+socks = ["socksio (==1.*)"]
+trio = ["trio (>=0.22.0,<1.0)"]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+description = "The next generation HTTP client."
+optional = false
+python-versions = ">=3.8"
+groups = ["main", "test"]
+files = [
+    {file = "httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"},
+    {file = "httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc"},
+]
+
+[package.dependencies]
+anyio = "*"
+certifi = "*"
+httpcore = "==1.*"
+idna = "*"
+
+[package.extras]
+brotli = ["brotli ; platform_python_implementation == \"CPython\"", "brotlicffi ; platform_python_implementation != \"CPython\""]
+cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
+http2 = ["h2 (>=3,<5)"]
+socks = ["socksio (==1.*)"]
+zstd = ["zstandard (>=0.18.0)"]
+
 [[package]]
 name = "idna"
 version = "3.10"
 description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
 python-versions = ">=3.6"
-groups = ["webserver"]
+groups = ["main", "test", "webserver"]
 files = [
     {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},
     {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},
@@ -464,7 +523,7 @@ version = "4.13.2"
 description = "PyMongo - the Official MongoDB Python driver"
 optional = false
 python-versions = ">=3.9"
-groups = ["main"]
+groups = ["test", "webserver"]
 files = [
     {file = "pymongo-4.13.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:01065eb1838e3621a30045ab14d1a60ee62e01f65b7cf154e69c5c722ef14d2f"},
     {file = "pymongo-4.13.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9ab0325d436075f5f1901cde95afae811141d162bc42d9a5befb647fda585ae6"},
@@ -538,6 +597,21 @@ snappy = ["python-snappy"]
 test = ["pytest (>=8.2)", "pytest-asyncio (>=0.24.0)"]
 zstd = ["zstandard"]
 
+[[package]]
+name = "pymongo-inmemory"
+version = "0.5.0"
+description = "A mongo mocking library with an ephemeral MongoDB running in memory."
+optional = false
+python-versions = "<4.0,>=3.9"
+groups = ["test"]
+files = [
+    {file = "pymongo_inmemory-0.5.0-py3-none-any.whl", hash = "sha256:ebad4ccc9d9bed859ad25932f039aadb476f29c6945df57fdba0f9171f6626a1"},
+    {file = "pymongo_inmemory-0.5.0.tar.gz", hash = "sha256:2af2a6bab1cda9a27f524737ce6d3c9ff8cb9e52c224537e5742d610c4aa677e"},
+]
+
+[package.dependencies]
+pymongo = "*"
+
 [[package]]
 name = "pytest"
 version = "8.3.5"
@@ -705,7 +779,7 @@ version = "1.3.1"
 description = "Sniff out which async library your code is running under"
 optional = false
 python-versions = ">=3.7"
-groups = ["webserver"]
+groups = ["main", "test", "webserver"]
 files = [
     {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"},
     {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"},
@@ -821,12 +895,12 @@ version = "4.13.2"
 description = "Backported and Experimental Type Hints for Python 3.8+"
 optional = false
 python-versions = ">=3.8"
-groups = ["main", "webserver"]
+groups = ["main", "test", "webserver"]
 files = [
     {file = "typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c"},
     {file = "typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef"},
 ]
-markers = {main = "python_version == \"3.10\""}
+markers = {main = "python_version < \"3.13\"", test = "python_version < \"3.13\""}
 
 [[package]]
 name = "typing-inspection"
@@ -866,4 +940,4 @@ standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.6.3)
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<4.0.0"
-content-hash = "bc0f1c385864ccdc10f7c7f3d3c886fe231a1dd70b3d45fa342825a49485879c"
+content-hash = "a31dd577fbe56afb94b935a7ec1feb8e146f5677cd9edb8869296d272afed9cc"

pyproject.toml

@@ -12,23 +12,26 @@ dependencies = [
     "nltk (>=3.9.1,<4.0.0)",
     "python-dotenv (>=1.1.0,<2.0.0)",
     "structlog (>=25.2.0,<26.0.0)",
-    "pymongo[srv] (>=4.13.2,<5.0.0)",
+    "httpx (>=0.28.1,<0.29.0)"
 ]
 
 [tool.poetry.group.test]
 optional = true
 
 [tool.poetry.group.test.dependencies]
+pymongo-inmemory = "^0.5.0"
 pytest = "^8.3.5"
 pytest-cov = "^6.1.1"
+httpx = "^0.28.1"
 
 [tool.poetry.group.webserver]
 optional = true
 
 [tool.poetry.group.webserver.dependencies]
+asgi-correlation-id = "^4.3.4"
 fastapi = "^0.115.12"
 uvicorn = "^0.34.2"
-asgi-correlation-id = "^4.3.4"
+pymongo = {extras = ["srv"], version = "^4.13.2"}
 
 [tool.pytest.ini_options]
 addopts = "--cov=my_ghost_writer --cov-report html"

requirements.txt

@@ -1,3 +1,4 @@
 nltk==3.9.1
+pymongo~=4.13.2
 python-dotenv==1.1.0
-structlog==25.2.0
+structlog==25.2.0

template.env

@@ -4,6 +4,11 @@ ALLOWED_ORIGIN=http://localhost:7860,http://localhost:8000
 WORDSAPI_KEY=
 WORDSAPI_URL=https://wordsapiv1.p.rapidapi.com/words
 RAPIDAPI_HOST=wordsapiv1.p.rapidapi.com
+MONGO_USE_OK=
+MONGO_CONNECTION_STRING_LOCAL=mongodb://localhost:27017
 MONGO_CONNECTION_STRING=mongodb://localhost:27017
-MONGO_CONNECTION_TIMEOUT=800
+MONGO_CONNECTION_TIMEOUT_LOCAL=200
+MONGO_CONNECTION_TIMEOUT_REMOTE=3000
+MONGO_CONNECTION_TIMEOUT=
+MONGO_HEALTHCHECK_SLEEP=900
 DEFAULT_COLLECTION_THESAURUS=wordsapi