feat: configured docker image

Author: JianLoong

.dockerignore

@@ -32,3 +32,4 @@
 **/values.dev.yaml
 LICENSE
 README.md
+database

Dockerfile

@@ -37,7 +37,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \
     python -m pip install -r requirements.txt
 
 # Switch to the non-privileged user to run the application.
-USER appuser
+# USER appuser
 
 # Copy the source code into the container.
 COPY . .

README.md

@@ -16,4 +16,6 @@ FROM submission s
 INNER JOIN breakdown ON s.id = breakdown.id
 GROUP BY sub_month, sub_year
 ORDER BY sub_month, sub_year;
-```
+```
+
+uvicorn main:app --reload   

analytics.py

@@ -13,15 +13,17 @@
 from nltk.tokenize import word_tokenize
 from nrclex import NRCLex
 from sqlmodel import Session, create_engine, select
-from endpoints.submission_api import SubmissionAPI
 
+from endpoints.database_config import DatabaseConfig
+from endpoints.submission_api import SubmissionAPI
 from models.submission import Submission
 from models.summary import Summary
 
 
 class AnalyticsProcessor:
     def __init__(self):
-        self.api = SubmissionAPI()
+        engine = DatabaseConfig().get_engine()
+        self.api = SubmissionAPI(engine)
 
     def process(self, submissions):
         afinn = Afinn()
@@ -153,36 +155,6 @@ def generate_search(self):
 
         self.write_to_file(json.dumps(indexes), "search")
 
-    def generate_top(self):
-        indexes = []
-
-        sqlite_file_name = "AmItheAsshole.db"
-        sqlite_url = f"sqlite:///database//{sqlite_file_name}"
-        engine = create_engine(sqlite_url, echo=False)
-        with Session(engine) as session:
-            statement = select(Submission)
-            results = session.exec(statement)
-            for submission in results:
-                entry = dict()
-                entry["id"] = submission.id
-                entry["scores"] = submission.score
-                entry["created_utc"] = submission.created_utc
-
-                try:
-                    summary: Summary = self.api.read_summary(submission.id)
-                    entry["nta"] = summary.counts["nta_count"]
-                    entry["yta"] = summary.counts["yta_count"]
-                    entry["esh"] = summary.counts["esh_count"]
-                    entry["info"] = summary.counts["info_count"]
-                    entry["nah"] = summary.counts["nah_count"]
-                except Exception:
-                    continue
-                indexes.append(entry)
-
-        self.write_to_file(json.dumps(indexes), "top")
-
-        return indexes
-
     def write_to_file(self, json, file_name):
         f = open("./endpoints/static/" + str(file_name) + ".json", "w")
         f.write(json)

compose.yaml

@@ -13,6 +13,10 @@ services:
       context: .
     ports:
       - 8000:8000
+    env_file:
+      - .env
+    volumes:
+      - ./database/:/app/database
 
 # The commented out section below is an example of how to define a PostgreSQL
 # database that your application can use. `depends_on` tells Docker Compose to
@@ -46,4 +50,3 @@ services:
 # secrets:
 #   db-password:
 #     file: db/password.txt
-

crawler.py

@@ -3,6 +3,7 @@
 import logging
 import os
 from endpoints.comment_api import CommentAPI
+from endpoints.database_config import DatabaseConfig
 from endpoints.submission_api import SubmissionAPI
 from models.comment import Comment
 from models.submission import Submission
@@ -32,10 +33,14 @@ def crawl(self) -> None:
             user_agent=self.agent,
         )
 
-        submission_api = SubmissionAPI()
-        comment_api = CommentAPI()
+        db_config = DatabaseConfig()
 
-        for submission in reddit.subreddit(self.subreddit_name).new(
+        engine = db_config.get_engine()
+
+        submission_api = SubmissionAPI(engine)
+        comment_api = CommentAPI(engine)
+
+        for submission in reddit.subreddit(self.subreddit_name).hot(
             limit=self.post_limit
         ):
             custom_submission: Submission = Submission()

endpoints/breakdown_api.py

@@ -1,32 +1,17 @@
-import logging
-import os
 from fastapi import APIRouter
+from sqlalchemy import Engine
+from sqlmodel import Session
 
-from dotenv import dotenv_values
-from sqlmodel import Session, SQLModel, create_engine
 from models.breakdown import Breakdown
 
 
 class BreakdownAPI:
-    def __init__(self):
-        logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
-
-        self._configure_database()
-        self._create_db_and_tables()
+    def __init__(self, engine: Engine):
+        self.engine = engine
         self.router = APIRouter()
 
         self._setup_breakdown_routes()
 
-    def _create_db_and_tables(self):
-        SQLModel.metadata.create_all(self.engine)
-
-    def _configure_database(self):
-        config = dotenv_values(".env")
-        self.sqlite_file_name = config.get("DATABASE_NAME")
-        self.sqlite_url = f"sqlite:///database//{self.sqlite_file_name}"
-
-        self.engine = create_engine(self.sqlite_url, echo=False)
-
     def _setup_breakdown_routes(self) -> None:
         ...
 

endpoints/comment_api.py

@@ -1,20 +1,15 @@
-import logging
-import os
-from fastapi import APIRouter, HTTPException, Query
-
+from sqlalchemy import Engine
 from dotenv import dotenv_values
+from fastapi import APIRouter, HTTPException, Query
 from sqlmodel import Session, SQLModel, create_engine, select
+
 from models.comment import Comment
 
 
 class CommentAPI:
-    def __init__(self):
-        logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
-
-        self._configure_database()
-        self._create_db_and_tables()
+    def __init__(self, engine: Engine):
+        self.engine = engine
         self.router = APIRouter()
-
         self._setup_comment_routes()
 
     def _create_db_and_tables(self):

endpoints/database_config.py

@@ -0,0 +1,35 @@
+import logging
+import os
+
+
+from dotenv import load_dotenv, find_dotenv
+from sqlalchemy import Engine
+from sqlmodel import SQLModel, create_engine
+
+
+class DatabaseConfig:
+    _instance = None
+
+    def _setup_database(self):
+        load_dotenv(find_dotenv())
+        # config = dotenv_values(".env")
+        sqlite_file_name = os.environ.get("DATABASE_NAME")
+        sqlite_url = f"sqlite:///database//{sqlite_file_name}"
+
+        print(sqlite_url)
+
+        self.engine = create_engine(sqlite_url, echo=False)
+
+        SQLModel.metadata.create_all(self.engine)
+
+    def get_engine(self) -> Engine:
+        return self.engine
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(DatabaseConfig, cls).__new__(cls)
+            logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
+
+            cls._instance._setup_database()
+
+        return cls._instance

endpoints/openai_inference_api.py

@@ -1,33 +1,19 @@
 import logging
-import os
 from fastapi import APIRouter, HTTPException
 
-from dotenv import dotenv_values
-from sqlmodel import Session, SQLModel, create_engine
+from sqlalchemy import Engine
+from sqlmodel import Session
 
 from models.openai_analytics import OpenAIAnalysis
 
 
 class OpenAIInferenceAPI:
-    def __init__(self):
-        logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
-
-        self._configure_database()
-        self._create_db_and_tables()
+    def __init__(self, engine: Engine):
+        self.engine = engine
         self.router = APIRouter()
 
         self._setup_openai_analysis_routes()
 
-    def _create_db_and_tables(self):
-        SQLModel.metadata.create_all(self.engine)
-
-    def _configure_database(self):
-        config = dotenv_values(".env")
-        self.sqlite_file_name = config.get("DATABASE_NAME")
-        self.sqlite_url = f"sqlite:///database//{self.sqlite_file_name}"
-
-        self.engine = create_engine(self.sqlite_url, echo=False)
-
     def _setup_openai_analysis_routes(self) -> None:
         self.router.add_api_route(
             "/openai_analysis/{id}",
@@ -45,7 +31,7 @@ def create_opeai_analysis(self, open_ai_analysis: OpenAIAnalysis):
             session.refresh(open_ai_analysis)
             return open_ai_analysis
 
-    def read_openai_inference(self, id: int):
+    def read_openai_inference(self, id: int) -> OpenAIAnalysis:
         with Session(self.engine) as session:
             open_ai_inference = session.get(OpenAIAnalysis, id)
             if not open_ai_inference:

endpoints/static/top.json

@@ -3,24 +3,14 @@
 import os
 
 from fastapi import APIRouter
-from sqlmodel import SQLModel, create_engine
 
 
 class StaticAPI:
-    def create_db_and_tables(self):
-        SQLModel.metadata.create_all(self.engine)
-
-    def configure_database(self):
-        self.sqlite_file_name = "AmItheAsshole.db"
-        self.sqlite_url = f"sqlite:///database//{self.sqlite_file_name}"
-
-        self.engine = create_engine(self.sqlite_url, echo=False)
-
     def __init__(self):
         logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
 
-        self.configure_database()
-        self.create_db_and_tables()
+        # self.configure_database()
+        # self.create_db_and_tables()
         self.router = APIRouter()
 
         self._setup_breakdown_routes()