Refactor PasteDataAware to use encoded_content and plain_content properties. Introduce utility functions for Base64 encoding and decoding.

Author: socraticDevBlog

backend/app/models.py

@@ -1,9 +1,10 @@
-import base64
 import time
 from typing import Optional
 
 from pydantic import BaseModel, Field
 
+from app.utils import from_base64, is_base64, to_base64
+
 
 class PasteInputModel(BaseModel):
     """
@@ -38,59 +39,39 @@ class PasteDataAware:
     content: str
     client_id: str
     created_at: int
-    content_encoding: str = Field(
-        default="utf-8",
-        description="Encoding used for the content. Default is 'utf-8'.",
-    )
 
     def __init__(
         self,
         content: str,
         client_id: str,
         created_at: Optional[int] = None,
         paste_id: str = None,
-        content_encoding: str = "utf-8",
     ):
         self.paste_id = paste_id
-        self._content = (
-            content
-            if self._is_base64(content)
-            else base64.b64encode(content.encode(content_encoding)).decode(
-                content_encoding
-            )
-        )
+        self._content = content if is_base64(content) else to_base64(content)
         self.client_id = client_id
         self.created_at = int(time.time()) if created_at is None else created_at
-        self.content_encoding = content_encoding
 
-    def _is_base64(self, s: str) -> bool:
+    @property
+    def encoded_content(self) -> str:
         """
-        Check if a string is valid Base64.
-
-        Args:
-            s (str): The string to check.
+        Get the decoded content of the paste.
 
         Returns:
-            bool: True if the string is valid Base64, False otherwise.
+            str: The decoded content of the paste.
         """
-        try:
-            # Decode and re-encode to verify Base64 validity
-            return base64.b64encode(base64.b64decode(s)).decode("utf-8") == s
-        except Exception:
-            return False
+        return self._content if is_base64(self._content) else to_base64(self._content)
 
-    def plain_content(self):
+    @property
+    def plain_content(self) -> str:
         """
-        Returns the content of the paste in plain text format.
+        Get the plain content of the paste.
 
+        Returns:
+            str: The plain content of the paste.
         """
-        return base64.b64decode(self._content.encode(self.content_encoding)).decode(
-            self.content_encoding
+        return (
+            self._content
+            if not is_base64(self._content)
+            else from_base64(self._content)
         )
-
-    def base64_content(self):
-        """
-        Returns the content of the paste in base64 format.
-
-        """
-        return self._content

backend/app/routes.py

@@ -37,7 +37,7 @@ async def get_paste(id: str, request: Request, db_client=Depends(get_db_client))
     is_web_browser = "Mozilla" in user_agent or "AppleWebKit" in user_agent
 
     paste_model = PasteModel(
-        content=paste.plain_content(),
+        content=paste.plain_content,
         paste_id=paste.paste_id,
         workspace=paste.client_id,
     )

backend/app/services/db_client.py

@@ -97,7 +97,7 @@ async def insert_paste(self, paste: PasteDataAware) -> str:
             RETURNING id, paste_id;
             """
             result = await conn.fetchrow(
-                insert_query, paste.base64_content(), paste.client_id, paste.created_at
+                insert_query, paste.encoded_content, paste.client_id, paste.created_at
             )
 
             return result["paste_id"]

backend/app/utils.py

@@ -0,0 +1,49 @@
+DEFAULT_ENCODING = "utf-8"
+import base64
+
+DEFAULT_ENCODING = "utf-8"
+
+
+def is_base64(s: str, encoding: str = DEFAULT_ENCODING) -> bool:
+    """
+    Check if a string is valid Base64.
+
+    Args:
+        s (str): The string to check.
+
+    Returns:
+        bool: True if the string is valid Base64, False otherwise.
+    """
+    try:
+        # Decode and re-encode to verify Base64 validity
+        return base64.b64encode(base64.b64decode(s)).decode(encoding=encoding) == s
+    except Exception:
+        return False
+
+
+def to_base64(s: str, encoding: str = DEFAULT_ENCODING) -> str:
+    """
+    Convert a string to Base64.
+
+    Args:
+        s (str): The string to convert.
+        encoding (str): The encoding to use. Defaults to 'utf-8'.
+
+    Returns:
+        str: The Base64 encoded string.
+    """
+    return base64.b64encode(s.encode(encoding=encoding)).decode(encoding=encoding)
+
+
+def from_base64(s: str, encoding: str = DEFAULT_ENCODING) -> str:
+    """
+    Convert a Base64 string to its original form.
+
+    Args:
+        s (str): The Base64 string to convert.
+        encoding (str): The encoding to use. Defaults to 'utf-8'.
+
+    Returns:
+        str: The decoded string.
+    """
+    return base64.b64decode(s.encode(encoding=encoding)).decode(encoding=encoding)