feat: ensuring dotenv while keeping pep8

Author: wjohnsto

__test__/todos_test.py

@@ -1,9 +1,12 @@
+from dotenv import load_dotenv
 import asyncio
 import pytest
-from app.redis import redis
+from app.redis import get_client
 from app.components.todos.store import TodoStatus, TodoStore
 
-todos = TodoStore(redis)
+load_dotenv()
+
+todos = TodoStore(get_client())
 
 @pytest.fixture(autouse=True)
 async def run_around_each():

src/app/components/todos/router.py

@@ -5,14 +5,20 @@
 from pydantic import BaseModel
 
 from app.components.todos.store import Todo, TodoDocument, Todos, TodoStatus, TodoStore
-from app.redis import redis
+from app.redis import get_client
 
-todos = TodoStore(redis)
+todos_store: TodoStore | None = None
+
+def get_todos() -> TodoStore:
+    global todos_store
+
+    return todos_store if todos_store is not None else TodoStore(get_client())
 
 
 @asynccontextmanager
 async def lifespan(_: FastAPI) -> AsyncIterator[Never]:
     # before
+    todos = get_todos()
     await todos.initialize()
     yield  # type: ignore
     # after
@@ -24,16 +30,19 @@ async def lifespan(_: FastAPI) -> AsyncIterator[Never]:
 
 @router.get("/", tags=["todos"])
 async def all() -> Todos:
+    todos = get_todos()
     return await todos.all()
 
 
 @router.get("/search", tags=["todos"])
 async def search(name: str | None = None, status: TodoStatus | None = None) -> Todos:
+    todos = get_todos()
     return await todos.search(name, status)
 
 
 @router.get("/{id}", tags=["todos"])
 async def one(id: str) -> Todo:
+    todos = get_todos()
     return await todos.one(id)
 
 
@@ -44,6 +53,7 @@ class CreateTodo(BaseModel):
 
 @router.post("/", tags=["todos"])
 async def create(todo: CreateTodo) -> TodoDocument:
+    todos = get_todos()
     return await todos.create(todo.id, todo.name)
 
 
@@ -53,9 +63,11 @@ class UpdateTodo(BaseModel):
 
 @router.patch("/{id}", tags=["todos"])
 async def update(id: str, todo: UpdateTodo) -> Todo:
+    todos = get_todos()
     return await todos.update(id, todo.status)
 
 
 @router.delete("/{id}", tags=["todos"])
 async def delete(id: str) -> None:
+    todos = get_todos()
     return await todos.delete(id)

src/app/components/todos/store.py

@@ -21,12 +21,20 @@
 
 
 class TodoStatus(str, Enum):
+    """
+    An enum for todo status
+    """
+
     todo = "todo"
     in_progress = "in progress"
     complete = "complete"
 
 
 class Todo(BaseModel):
+    """
+    Defines a todo
+    """
+
     name: str
     status: TodoStatus
     created_date: datetime | None = None
@@ -42,28 +50,44 @@ def serialize_updated_date(self, dt: datetime) -> str:
 
 
 class TodoDocument(BaseModel):
+    """
+    Defines a todo document including id as returned from redis
+    """
+
     id: str
     value: Todo
 
 
 class Todos(BaseModel):
+    """
+    Defines a list of todos and a total, mapping to the results of FT.SEARCH
+    """
+
     total: int
     documents: List[TodoDocument]
 
 
 class TodoStore:
-    """Stores todos"""
+    """
+    Stores and retrieves todos in redis
+    """
 
     def __init__(self, redis: Redis):
         self.redis = redis
         self.INDEX = TODOS_INDEX
         self.PREFIX = TODOS_PREFIX
 
     async def initialize(self) -> None:
+        """
+        Sets up redis to be used with todos
+        """
         await self.create_index_if_not_exists()
         return None
 
     async def have_index(self) -> bool:
+        """
+        Checks if the TODOS_INDEX already exists in Redis
+        """
         try:
             await self.redis.ft(self.INDEX).info()
         except ResponseError as e:
@@ -75,6 +99,9 @@ async def have_index(self) -> bool:
         return True
 
     async def create_index_if_not_exists(self) -> None:
+        """
+        Creates the TODOS_INDEX if it doesn't exist already
+        """
         if await self.have_index():
             return None
 
@@ -101,6 +128,9 @@ async def create_index_if_not_exists(self) -> None:
         return None
 
     async def drop_index(self) -> None:
+        """
+        Drops the TODOS_INDEX if it exists
+        """
         if not await self.have_index():
             return None
 
@@ -115,36 +145,52 @@ async def drop_index(self) -> None:
         return None
 
     def format_id(self, id: str) -> str:
+        """
+        Allow for id with or without TODOS_PREFIX
+        """
         if re.match(f"^{self.PREFIX}", id):
             return id
 
         return f"{self.PREFIX}{id}"
 
-    def parse_todo_document(self, todo: Document) -> TodoDocument:
+    def deserialize_todo_document(self, todo: Document) -> TodoDocument:
+        """
+        Deserializes a TodoDocument from JSON
+        """
         return TodoDocument(
             id=todo.id,
             value=Todo(**from_json(todo.json, allow_partial=True)),  # type: ignore
         )
 
-    def parse_todo_documents(self, todos: list[Document]) -> list[TodoDocument]:
+    def deserialize_todo_documents(self, todos: list[Document]) -> list[TodoDocument]:
+        """
+        Deserializes a list[TodoDocument] from list[JSON]
+        """
         todo_docs = []
 
         for doc in todos:
-            todo_docs.append(self.parse_todo_document(doc))
+            todo_docs.append(self.deserialize_todo_document(doc))
 
         return todo_docs
 
     async def all(self) -> Todos:
+        """
+        Gets all todos
+        """
         try:
             result = await self.redis.ft(self.INDEX).search("*")
             return Todos(
-                total=result.total, documents=self.parse_todo_documents(result.docs)
+                total=result.total,
+                documents=self.deserialize_todo_documents(result.docs),
             )
         except Exception as e:
             logger.error(f"Error getting all todos: {e}")
             raise
 
     async def one(self, id: str) -> Todo:
+        """
+        Gets a todo by id
+        """
         id = self.format_id(id)
 
         try:
@@ -156,6 +202,9 @@ async def one(self, id: str) -> Todo:
         return Todo(**json)
 
     async def search(self, name: str | None, status: TodoStatus | None) -> Todos:
+        """
+        Searches for todos by name and/or status
+        """
         searches = []
 
         if name is not None and len(name) > 0:
@@ -167,13 +216,17 @@ async def search(self, name: str | None, status: TodoStatus | None) -> Todos:
         try:
             result = await self.redis.ft(self.INDEX).search(Query(" ".join(searches)))
             return Todos(
-                total=result.total, documents=self.parse_todo_documents(result.docs)
+                total=result.total,
+                documents=self.deserialize_todo_documents(result.docs),
             )
         except Exception as e:
             logger.error(f"Error getting todo {id}: {e}")
             raise
 
     async def create(self, id: Optional[str], name: Optional[str]) -> TodoDocument:
+        """
+        Creates a todo
+        """
         dt = datetime.now(UTC)
 
         if name is None:
@@ -201,6 +254,9 @@ async def create(self, id: Optional[str], name: Optional[str]) -> TodoDocument:
         return todo
 
     async def update(self, id: str, status: TodoStatus) -> Todo:
+        """
+        Updates a todo
+        """
         dt = datetime.now(UTC)
 
         todo = await self.one(id)
@@ -222,6 +278,9 @@ async def update(self, id: str, status: TodoStatus) -> Todo:
         return todo
 
     async def delete(self, id: str) -> None:
+        """
+        Deletes a todo
+        """
         try:
             await self.redis.json().delete(self.format_id(id))
         except Exception as e:
@@ -231,6 +290,9 @@ async def delete(self, id: str) -> None:
         return None
 
     async def delete_all(self) -> None:
+        """
+        Delete all todos
+        """
         todos = await self.all()
         coros = []
 

src/app/env.py

@@ -1,6 +1,8 @@
+from dotenv import load_dotenv
 from fastapi import FastAPI
 
 from app.components.todos.router import router as todos_router
 
+load_dotenv()
 app = FastAPI()
 app.include_router(router=todos_router, prefix="/api/todos")

src/app/main.py

@@ -5,11 +5,25 @@
 from redis.exceptions import ConnectionError, TimeoutError
 from redis.retry import Retry
 
-redis_url = os.environ.get("REDIS_URL", "redis://localhost:6379")
-redis = Redis.from_url(
-    redis_url,
-    decode_responses=True,
-    retry=Retry(ExponentialBackoff(cap=10, base=1), 25),
-    retry_on_error=[ConnectionError, TimeoutError, ConnectionResetError],
-    health_check_interval=1,
-)
+clients: dict[str, Redis] = {}
+
+
+def get_client(url: str | None = None) -> Redis:
+    redis_url = (
+        url
+        if url is not None
+        else os.environ.get("REDIS_URL", "redis://localhost:6379")
+    )
+
+    if redis_url in clients:
+        return clients[redis_url]
+
+    clients[redis_url] = Redis.from_url(
+        redis_url,
+        decode_responses=True,
+        retry=Retry(ExponentialBackoff(cap=10, base=1), 25),
+        retry_on_error=[ConnectionError, TimeoutError, ConnectionResetError],
+        health_check_interval=1,
+    )
+
+    return clients[redis_url]