Refactor tutorial.

Author: toddbirchard

.env.example

@@ -1,2 +1,6 @@
-SQLALCHEMY_DATABASE_URI=mysql+pymysql://myuser:mypassword@host.example.com:1234/mydatabase
-SQLALCHEMY_DATABASE_PEM="-----BEGIN CERTIFICATE-----\nghdfigfjvgkjdfvfjkhcvdfjhvfghjbfdvfjshdvjghvfgjvcfjdcvckdjh\n-----END CERTIFICATE-----\n"
+DATABASE_USERNAME="yourusername"
+DATABASE_PASSWORD="yourpassword"
+DATABASE_HOST="db.host.com"
+DATABASE_PORT=12345
+DATABASE_TABLE="table"
+DATABASE_CERT_FILE="ca-certificate.crt"

.github/sqlalchemy@2x.jpg renamed to .github/img/sqlalchemy@2x.jpg

@@ -89,6 +89,8 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+creds/
+**/*.crt
 
 # Spyder project settings
 .spyderproject
@@ -115,6 +117,7 @@ ca-certificate.crt
 
 # Idea
 .idea/
+.vscode/
 
 # logs
 logs/*

.gitignore

@@ -1,14 +1,14 @@
 # SQLAlchemy Tutorial
 
-![Python](https://img.shields.io/badge/Python-v^3.8-blue.svg?logo=python&longCache=true&logoColor=white&colorB=5e81ac&style=flat-square&colorA=4c566a)
-![SQLAlchemy](https://img.shields.io/badge/SQLAlchemy-v^1.4.0-blue.svg?longCache=true&logo=python&style=flat-square&logoColor=white&colorB=5e81ac&colorA=4c566a)
-![PyMySQL](https://img.shields.io/badge/PyMySQL-v^1.0.0-red.svg?longCache=true&style=flat-square&logo=scala&logoColor=white&colorA=4c566a&colorB=bf616a)
+![Python](https://img.shields.io/badge/Python-v^3.10-blue.svg?logo=python&longCache=true&logoColor=white&colorB=5e81ac&style=flat-square&colorA=4c566a)
+![SQLAlchemy](https://img.shields.io/badge/SQLAlchemy-v^2.0.20-blue.svg?longCache=true&logo=python&style=flat-square&logoColor=white&colorB=5e81ac&colorA=4c566a)
+![PyMySQL](https://img.shields.io/badge/PyMySQL-v^1.1.0-red.svg?longCache=true&style=flat-square&logo=scala&logoColor=white&colorA=4c566a&colorB=bf616a)
 ![GitHub Last Commit](https://img.shields.io/github/last-commit/google/skia.svg?style=flat-square&colorA=4c566a&colorB=a3be8c&logo=GitHub)
 [![GitHub Issues](https://img.shields.io/github/issues/hackersandslackers/sqlalchemy-tutorial.svg?style=flat-square&colorA=4c566a&logo=GitHub&colorB=ebcb8b)](https://github.com/hackersandslackers/sqlalchemy-tutorial/issues)
 [![GitHub Stars](https://img.shields.io/github/stars/hackersandslackers/sqlalchemy-tutorial.svg?style=flat-square&colorA=4c566a&logo=GitHub&colorB=ebcb8b)](https://github.com/hackersandslackers/sqlalchemy-tutorial/stargazers)
 [![GitHub Forks](https://img.shields.io/github/forks/hackersandslackers/sqlalchemy-tutorial.svg?style=flat-square&colorA=4c566a&logo=GitHub&colorB=ebcb8b)](https://github.com/hackersandslackers/sqlalchemy-tutorial/network)
 
-![SQLAlchemy Tutorial](https://github.com/hackersandslackers/sqlalchemy-tutorial/blob/master/.github/sqlalchemy@2x.jpg?raw=true)
+![SQLAlchemy Tutorial](https://github.com/hackersandslackers/sqlalchemy-tutorial/blob/master/.github/img/sqlalchemy@2x.jpg?raw=true)
 
 This repository contains the source code for a four-part tutorial series on SQLAlchemy:
 
@@ -17,29 +17,32 @@ This repository contains the source code for a four-part tutorial series on SQLA
 3. [Relationships in SQLAlchemy Data Models](https://hackersandslackers.com/sqlalchemy-data-models)
 4. [Constructing Database Queries with SQLAlchemy](https://hackersandslackers.com/database-queries-sqlalchemy-orm)
 
-# Getting Started
+## Getting Started
 
 Get set up locally in two steps:
 
 ### Environment Variables
 
 Replace the values in **.env.example** with your values and rename this file to **.env**:
 
-
-* `SQLALCHEMY_DATABASE_URI`: Connection URI of a SQL database.
-* `SQLALCHEMY_DATABASE_PEM` _(Optional)_: PEM key for databases requiring an SSL connection.
+* `DATABASE_USERNAME`: Username for a SQL database.
+* `DATABASE_PASSWORD`: Corresponding password for the above SQL database user.
+* `DATABASE_HOST`: Host of the SQL database.
+* `DATABASE_PORT`: Numerical port of the SQL database.
+* `DATABASE_TABLE`: Name of the SQL database table.
+* `DATABASE_CERT_FILE` _(optional)_: Path to SSL certificate file for database.
 
 *Remember never to commit secrets saved in .env files to Github.*
 
 ### Installation
 
-Get up and running with `make deploy`:
+Get up and running with `make run`:
 
 ```shell
-$ git clone https://github.com/hackersandslackers/sqlalchemy-tutorial.git
-$ cd sqlalchemy-tutorial
-$ make deploy
-``` 
+git clone https://github.com/hackersandslackers/sqlalchemy-tutorial.git
+cd sqlalchemy-tutorial
+make run
+```
 
 -----
 

README.md

@@ -1,5 +1,5 @@
 """Database config."""
-from os import environ, path
+from os import getenv, path
 
 from dotenv import load_dotenv
 
@@ -8,8 +8,14 @@
 load_dotenv(path.join(basedir, ".env"))
 
 # Database connection variables
-SQLALCHEMY_DATABASE_URI = environ.get("SQLALCHEMY_DATABASE_URI")
-SQLALCHEMY_DATABASE_PEM = environ.get("SQLALCHEMY_DATABASE_PEM")
+DATABASE_USERNAME = getenv("DATABASE_USERNAME")
+DATABASE_PASSWORD = getenv("DATABASE_PASSWORD")
+DATABASE_HOST = getenv("DATABASE_HOST")
+DATABASE_PORT = getenv("DATABASE_PORT")
+DATABASE_TABLE = getenv("DATABASE_TABLE")
+DATABASE_CERT_FILE = getenv("DATABASE_CERT_FILE")
+
+SQLALCHEMY_DATABASE_URI = f"mysql+pymysql://{DATABASE_USERNAME}:{DATABASE_PASSWORD}@{DATABASE_HOST}:{DATABASE_PORT}/{DATABASE_TABLE}?ssl_ca={DATABASE_CERT_FILE}"
 
 # Reset data after each run
 CLEANUP_DATA = False

config.py

@@ -1 +1,12 @@
-from .db import engine, session
+"""Create SQLAlchemy engine and session objects."""
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from config import SQLALCHEMY_DATABASE_URI
+
+# Create database engine
+engine = create_engine(SQLALCHEMY_DATABASE_URI, echo=False)
+
+# Create database session
+Session = sessionmaker(bind=engine)
+session = Session()

database/__init__.py

@@ -8,34 +8,19 @@ def formatter(log: dict) -> str:
     """
     Format log colors based on level.
 
-    :param log: Logged event stored as map containing contextual metadata.
-    :type log: dict
+    :param dict log: Logged event stored as map containing contextual metadata.
+
     :returns: str
     """
+    if log["level"].name == "INFO":
+        return "<fg #5278a3>{time:MM-DD-YYYY HH:mm:ss}</fg #5278a3> | <fg #b3cfe7>{level}</fg #b3cfe7>: <light-white>{message}</light-white>\n"
     if log["level"].name == "WARNING":
-        return (
-            "<white>{time:MM-DD-YYYY HH:mm:ss}</white> | "
-            "<light-yellow>{level}</light-yellow>: "
-            "<light-white>{message}</light-white> \n"
-        )
-    elif log["level"].name == "ERROR":
-        return (
-            "<white>{time:MM-DD-YYYY HH:mm:ss}</white> | "
-            "<light-red>{level}</light-red>: "
-            "<light-white>{message}</light-white> \n"
-        )
-    elif log["level"].name == "SUCCESS":
-        return (
-            "<white>{time:MM-DD-YYYY HH:mm:ss}</white> | "
-            "<light-green>{level}</light-green>: "
-            "<light-white>{message}</light-white> \n"
-        )
-    else:
-        return (
-            "<white>{time:MM-DD-YYYY HH:mm:ss}</white> | "
-            "<fg #67c9c4>{level}</fg #67c9c4>: "
-            "<light-white>{message}</light-white> \n"
-        )
+        return "<fg #5278a3>{time:MM-DD-YYYY HH:mm:ss}</fg #5278a3> | <fg #b09057>{level}</fg #b09057>: <light-white>{message}</light-white>\n"
+    if log["level"].name == "SUCCESS":
+        return "<fg #5278a3>{time:MM-DD-YYYY HH:mm:ss}</fg #5278a3> | <fg #6dac77>{level}</fg #6dac77>: <light-white>{message}</light-white>\n"
+    if log["level"].name == "ERROR":
+        return "<fg #5278a3>{time:MM-DD-YYYY HH:mm:ss}</fg #5278a3> | <fg #a35252>{level}</fg #a35252>: <light-white>{message}</light-white>\n"
+    return "<fg #5278a3>{time:MM-DD-YYYY HH:mm:ss}</fg #5278a3> | <fg #b3cfe7>{level}</fg #b3cfe7>: <light-white>{message}</light-white>\n"
 
 
 def create_logger() -> custom_logger:

database/db.py

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sqlalchemy-tutorial"
-version = "0.1.0"
+version = "0.1.1"
 description = "Use SQLAlchemy to connect, query, and interact with relational databases."
 authors = ["Todd Birchard <todd@hackersandslackers.com>"]
 maintainers = ["Todd Birchard <todd@hackersandslackers.com>"]
@@ -9,13 +9,7 @@ readme = "README.md"
 homepage = "https://github.com/hackersandslackers/sqlalchemy-tutorial/"
 repository = "https://github.com/hackersandslackers/sqlalchemy-tutorial/"
 documentation = "https://github.com/hackersandslackers/sqlalchemy-tutorial/"
-keywords = [
-  "SQL",
-  "SQLAlchemy",
-  "ORM",
-  "Relational Databases",
-  "RDBMS"
-]
+keywords = ["SQL", "SQLAlchemy", "ORM", "Relational Databases", "RDBMS"]
 
 [tool.poetry.dependencies]
 python = "^3.10, <4.0"
@@ -37,5 +31,11 @@ run = "main:init_script"
 issues = "https://github.com/hackersandslackers/sqlalchemy-tutorial/issues"
 
 [build-system]
-requires = ["poetry>=0.12"]
+requires = ["poetry>=1.6.1"]
 build-backend = "poetry.masonry.api"
+
+[tool.black]
+line-length = 120
+
+[tool.pylint.'MESSAGES CONTROL']
+disable = "C0103,C0301,W0703,W0621"

logger.py

@@ -26,4 +26,3 @@ def cleanup_data():
         LOGGER.error(f"SQLAlchemyError error when resetting data: {e}")
     except Exception as e:
         LOGGER.error(f"Unexpected error when resetting data: {e}")
-

poetry.lock

@@ -3,6 +3,7 @@
 
 from sqlalchemy import text
 from sqlalchemy.engine.base import Engine
+from sqlalchemy.exc import SQLAlchemyError
 
 from logger import LOGGER
 
@@ -11,41 +12,49 @@ def fetch_job_listings(engine: Engine) -> Optional[List[dict]]:
     """
     Select rows from database and parse as list of dicts.
 
-    :param engine: Database engine to handle raw SQL queries.
-    :type engine: engine
+    :param Engine engine: Database engine to handle raw SQL queries.
 
     :return: Optional[List[dict]]
     """
-    result = engine.execute(
-        text(
-            "SELECT job_id, agency, business_title, \
-            salary_range_from, salary_range_to \
-            FROM nyc_jobs ORDER BY RAND() LIMIT 10;"
-        )
-    )
-    rows = [dict(row) for row in result.fetchall()]
-    LOGGER.info(f"Selected {result.rowcount} rows: {rows}")
-    return rows
+    try:
+        with engine.begin() as conn:
+            result = conn.execute(
+                text(
+                    "SELECT job_id, agency, business_title, \
+                    salary_range_from, salary_range_to \
+                    FROM nyc_jobs ORDER BY RAND() LIMIT 10;"
+                ),
+            )
+            results = result.fetchall()
+            results_dict = [row._asdict() for row in results]
+            LOGGER.info(f"Selected {result.rowcount} rows.")
+            return results_dict
+    except SQLAlchemyError as e:
+        LOGGER.error(f"SQLAlchemyError while fetching records: {e}")
+    except Exception as e:
+        LOGGER.error(f"Unexpected error while fetching records: {e}")
 
 
 def update_job_listing(engine: Engine) -> Optional[List[dict]]:
     """
     Update row in database with problematic characters escaped.
 
-    :param engine: Engine object representing a SQL database.
-    :type engine: engine
+    :param Engine engine: Database engine to handle raw SQL queries.
 
     :return: Optional[List[dict]]
     """
-    result = engine.execute(
-        text(
-            "UPDATE nyc_jobs SET business_title = 'Senior QA Scapegoat 🏆', \
-            job_category = 'Information? <>!#%%Technology!%%#^&%* & Telecom' \
-            WHERE job_id = 229837;"
-        )
-    )
-    LOGGER.info(
-        f"Selected {result.rowcount} row: \
-        {result}"
-    )
-    return result.rowcount
+    try:
+        with engine.begin() as conn:
+            result = conn.execute(
+                text(
+                    "UPDATE nyc_jobs SET business_title = 'Senior QA Scapegoat 🏆', \
+                    job_category = 'Information? <>!#%%Technology!%%#^&%* & Telecom' \
+                    WHERE job_id = 229837;"
+                )
+            )
+            LOGGER.info(f"Updated {result.rowcount} row: {result}")
+            return result
+    except SQLAlchemyError as e:
+        LOGGER.error(f"SQLAlchemyError while updating records: {e}")
+    except Exception as e:
+        LOGGER.error(f"Unexpected error while updating records: {e}")

pyproject.toml

@@ -9,35 +9,15 @@ def get_all_posts(session: Session, admin_user: User):
     """
     Fetch all posts belonging to an author user.
 
-    :param session: SQLAlchemy database session.
-    :type session: Session
-    :param admin_user: Author of blog posts.
-    :type admin_user: User
+    :param Session session: SQLAlchemy database session.
+    :param User admin_user: Author of blog posts.
 
     :return: None
     """
-    posts = (
-        session.query(Post)
-        .join(User, Post.author_id == User.id)
-        .filter_by(username=admin_user.username)
-        .all()
-    )
+    LOGGER.info("Fetching posts with child comments...")
+    posts = session.query(Post).join(User, Post.author_id == User.id).filter_by(username=admin_user.username).all()
     for post in posts:
-        post_record = {
-            "post_id": post.id,
-            "title": post.title,
-            "summary": post.summary,
-            "status": post.status,
-            "feature_image": post.feature_image,
-            "author": {
-                "id": post.author_id,
-                "username": post.author.username,
-                "first_name": post.author.first_name,
-                "last_name": post.author.last_name,
-                "role": post.author.role,
-            },
-        }
-        LOGGER.info(post_record)
+        LOGGER.success(f"Fetched posts by user: {post}")
 
 
 def get_all_comments(session: Session):
@@ -49,17 +29,7 @@ def get_all_comments(session: Session):
 
     :return: None
     """
+    LOGGER.info("Joining comments with parent posts...")
     comments = session.query(Comment).join(Post, Post.id == Comment.post_id).all()
     for comment in comments:
-        comment_record = {
-            "comment_id": comment.id,
-            "body_summary": f"{comment.body[:50]}...",
-            "upvotes": comment.upvotes,
-            "comment_author_id": comment.user_id,
-            "post": {
-                "slug": comment.post.slug,
-                "title": comment.post.title,
-                "post_author": comment.post.author.username,
-            },
-        }
-        LOGGER.info(comment_record)
+        LOGGER.success(f"Joined comments with parent posts: {comment}")

sqlalchemy_tutorial/cleanup.py

@@ -28,7 +28,7 @@ class User(Base):
     updated_at = Column(DateTime, onupdate=func.now())
 
     def __repr__(self):
-        return "<User %r>" % self.username
+        return f"<User id={self.id}, username={self.username}, email={self.email}>"
 
 
 class Comment(Base):
@@ -48,7 +48,7 @@ class Comment(Base):
     user = relationship("User", backref="comment")
 
     def __repr__(self):
-        return "<Comment %r>" % self.id
+        return f"<Comment id={self.id}, post_id={self.post_id}, user_id={self.user_id}, upvotes={self.upvotes}, created_at={self.created_at}>"
 
 
 class Post(Base):
@@ -72,7 +72,7 @@ class Post(Base):
     comments = relationship("Comment", backref="post")
 
     def __repr__(self):
-        return "<Post %r>" % self.slug
+        return f"<Post id={self.id}, slug={self.slug}, title={self.title}, body={self.body}>"
 
 
 Base.metadata.create_all(engine)

sqlalchemy_tutorial/part1_connections/queries.py

@@ -1,6 +1,4 @@
 """Create records related to one another via SQLAlchemy's ORM."""
-from typing import Tuple
-
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 from sqlalchemy.orm import Session
 
@@ -12,17 +10,13 @@ def create_user(session: Session, user: User) -> User:
     """
     Create a new user if username isn't already taken.
 
-    :param session: SQLAlchemy database session.
-    :type session: Session
-    :param user: New user record to create.
-    :type user: User
+    :param Session session: SQLAlchemy database session.
+    :param User user: New user record to create.
 
     :return: Optional[User]
     """
     try:
-        existing_user = (
-            session.query(User).filter(User.username == user.username).first()
-        )
+        existing_user = session.query(User).filter(User.username == user.username).first()
         if existing_user is None:
             session.add(user)  # Add the user
             session.commit()  # Commit the change
@@ -42,10 +36,8 @@ def create_post(session: Session, post: Post) -> Post:
     """
     Create a post.
 
-    :param session: SQLAlchemy database session.
-    :type session: Session
-    :param post: Blog post to be created.
-    :type post: Post
+    :param Session session: SQLAlchemy database session.
+    :param Post post: Blog post to be created.
 
     :return: Post
     """
@@ -54,29 +46,24 @@ def create_post(session: Session, post: Post) -> Post:
         if existing_post is None:
             session.add(post)  # Add the post
             session.commit()  # Commit the change
-            LOGGER.success(
-                f"Created post {post} published by user {post.author.username}"
-            )
+            LOGGER.success(f"Created post {post} published by user {post.author.username}")
             return session.query(Post).filter(Post.slug == post.slug).first()
-        else:
-            LOGGER.warning(f"Post already exists in database: {post}")
-            return existing_post
+        LOGGER.warning(f"Post already exists in database: {post}")
+        return existing_post
     except IntegrityError as e:
-        LOGGER.error(e.orig)
-        raise e.orig
+        LOGGER.error(f"IntegrityError error when creating user: {e}")
     except SQLAlchemyError as e:
+        LOGGER.error(f"SQLAlchemyError error when creating user: {e}")
+    except Exception as e:
         LOGGER.error(f"Unexpected error when creating user: {e}")
-        raise e
 
 
 def create_comment(session: Session, comment: Comment) -> Comment:
     """
     Create a comment posted by `regular_user` on `admin_user`'s post.
 
-    :param session: SQLAlchemy database session.
-    :type session: Session
-    :param comment: User comment left on published post.
-    :type comment: Comment
+    :param Session session: SQLAlchemy database session.
+    :param Comment comment: User comment left on published post.
 
     :return: Comment
     """
@@ -86,8 +73,8 @@ def create_comment(session: Session, comment: Comment) -> Comment:
         LOGGER.success(f"Created comment {comment} from user {comment.user.username}.")
         return comment
     except IntegrityError as e:
-        LOGGER.error(e.orig)
-        raise e.orig
+        LOGGER.error(f"IntegrityError error when creating user: {e}")
     except SQLAlchemyError as e:
-        LOGGER.error(f"Unexpected error when creating comment: {e}")
-        raise e
+        LOGGER.error(f"SQLAlchemyError error when creating user: {e}")
+    except Exception as e:
+        LOGGER.error(f"Unexpected error when creating user: {e}")