style: Formatting and linting.

Author: mitjohnson

src/pyddns/__init__.py

@@ -3,13 +3,13 @@
 =====================================================================
 
 **pyddns** is a Python package providing easy, programmable ddns clients
-for multiple services. 
+for multiple services.
 """
 
 from .services.duckdns_service import DuckDNS
 from .services.cloudflare_service import CloudflareDNS
 
 __all__ = [
-    'CloudflareDNS',
-    'DuckDNS',
+    "CloudflareDNS",
+    "DuckDNS",
 ]

src/pyddns/cache.py

@@ -1,15 +1,17 @@
 """
 Storage Module
 
-This module provides a class for managing SQLite database operations specifically
+Provides a class for managing SQLite database operations specifically
 for Dynamic DNS (DDNS) services. The `Storage` class handles the creation,
 updating, and retrieval of domain records in a SQLite database.
 """
+
 import sqlite3
 import logging
 from typing import Optional, Callable, Any, Tuple
 from datetime import datetime
 
+
 class Storage:
     """
     A class to manage SQLite database operations for DDNS services.
@@ -18,15 +20,18 @@ class Storage:
     in a SQLite database.
     """
 
-    def __init__(self, filename: str='py_ddns.db'):
+    def __init__(self, filename: str = "py_ddns.db"):
         self.connection = sqlite3.connect(filename)
         self.cursor = self.connection.cursor()
 
         self.create_tables()
 
     @staticmethod
     def handle_sqlite_error(func: Callable) -> Callable:
-        """ Decorator utilized to handle all errors invlovling the SQLite Database."""
+        """
+        Decorator utilized to handle all errors involving the SQLite Database.
+        """
+
         def wrapper(*args, **kwargs) -> Any:
 
             try:
@@ -45,11 +50,12 @@ def wrapper(*args, **kwargs) -> Any:
             except sqlite3.IntegrityError as err:
                 logging.error("SQLite Integrity Error: %s", err)
                 raise
+
         return wrapper
 
     @handle_sqlite_error
     def create_tables(self) -> None:
-        """ Method to create all SQLite tables utilized by pyddns """
+        """Method to create all SQLite tables utilized by pyddns"""
 
         sql = """
         CREATE TABLE IF NOT EXISTS domains (
@@ -65,13 +71,17 @@ def create_tables(self) -> None:
         """
         self.cursor.execute(sql)
         self.connection.commit()
-        logging.debug("SQLite: Successfully verified that the domains table is present.")
+        logging.debug(
+            "SQLite: Successfully verified that the domains table is present."
+        )
 
     @handle_sqlite_error
     def drop_tables(self) -> None:
-        """ Method to drop all SQLite tables utilized by pyddns """
+        """Method to drop all SQLite tables utilized by pyddns"""
 
-        logging.warning("one or more database tables have been requested to be dropped.")
+        logging.warning(
+            "one or more database tables have been requested to be dropped."
+        )
 
         sql = """
         DROP TABLE IF EXISTS domains;
@@ -83,39 +93,61 @@ def drop_tables(self) -> None:
 
     @handle_sqlite_error
     def add_service(
-        self, service_name: str, domain_name: str, current_ip: str, record_id: Optional[str] = None
-        ) -> None:
-        """ Adds a service to the SQLite database and sets a created_at timestamp """
+        self,
+        service_name: str,
+        domain_name: str,
+        current_ip: str,
+        record_id: Optional[str] = None,
+    ) -> None:
+        """
+        Adds a service to the SQLite database and sets a created_at timestamp
+        """
 
         sql = """
         INSERT INTO domains(service, domain_name, current_ip, record_id)
         VALUES(?, ?, ?, ?)
         """
-        self.cursor.execute(sql, (service_name, domain_name, current_ip, record_id))
+        self.cursor.execute(
+            sql, (service_name, domain_name, current_ip, record_id)
+        )
         self.connection.commit()
         logging.debug(
-            "SQLite: Adding service: %s, Domain: %s, IP: %s", service_name, domain_name, current_ip
+            "SQLite: Adding service: %s, Domain: %s, IP: %s",
+            service_name,
+            domain_name,
+            current_ip,
         )
         logging.info("SQLite: Sucessfully added %s to database.", service_name)
 
     @handle_sqlite_error
-    def update_ip(self, service_name: str, domain_name: str, current_ip: str) -> None:
-        """ Updated the domain name's IP address in the SQLite database. """
+    def update_ip(
+        self, service_name: str, domain_name: str, current_ip: str
+    ) -> None:
+        """Updated the domain name's IP address in the SQLite database."""
 
         sql = """
         UPDATE domains
         SET service = COALESCE(?, service),
             current_ip = COALESCE(?, current_ip),
             last_updated = CURRENT_TIMESTAMP
-         WHERE domain_name = ? 
+         WHERE domain_name = ?
         """
         self.cursor.execute(sql, (service_name, current_ip, domain_name))
         self.connection.commit()
-        logging.info("SQLite: Updated %s on %s to %s", domain_name, service_name, current_ip)
+        logging.info(
+            "SQLite: Updated %s on %s to %s",
+            domain_name,
+            service_name,
+            current_ip,
+        )
 
     @handle_sqlite_error
-    def retrieve_record(self, domain_name: str) -> Optional[Tuple[str, datetime, str]]:
-        """ Retrieves IP adress, last_updated, and record_id from SQLite databse if present. """
+    def retrieve_record(
+        self, domain_name: str
+    ) -> Optional[Tuple[str, datetime, str]]:
+        """
+        Retrieves IP address, last_updated, and record_id from SQLite database
+        """
 
         sql = """
         SELECT current_ip, last_updated, record_id FROM domains

src/pyddns/client.py

@@ -6,11 +6,13 @@
 clients that interact with various DNS service providers. It includes methods
 for obtaining the current public IP address and updating DNS records.
 """
+
 from abc import ABC, abstractmethod
 import logging
 
 import requests
 
+
 class DDNSClient(ABC):
     """
     An abstract base class for Dynamic DNS (DDNS) clients.
@@ -21,14 +23,14 @@ class DDNSClient(ABC):
     Methods:
         INHERITED: get_ip() -> str: Retrieves the current public IP address.
         ABSTRACT: update_dns(ip_address: str, record_name: str) -> None"
-        """
+    """
 
     def get_ipv4(self) -> str:
-        """ Obtains current IPv4 adress and returns as a str. """
+        """Obtains current IPv4 adress and returns as a str."""
 
         logging.debug("Attempting to retrieve current public IP address.")
         try:
-            response = requests.get('https://api.ipify.org', timeout=10)
+            response = requests.get("https://api.ipify.org", timeout=10)
             response.raise_for_status()
 
             logging.info("Current IPv4 is %s", response.text)
@@ -40,4 +42,6 @@ def get_ipv4(self) -> str:
 
     @abstractmethod
     def update_dns(self, ip_address: str, record_name: str) -> None:
-        """ Abstract Method to force all clients to have an update_dns method. """
+        """
+        Abstract Method to force all clients to have an update_dns method.
+        """

src/pyddns/config.py

@@ -7,10 +7,12 @@
 the application, promoting efficient resource management and consistent access
 to configuration settings and data storage.
 """
+
 from configparser import ConfigParser
 import logging
 import os
 
+
 class Config:
     """
     A class to manage configuration settings using ConfigParser.
@@ -19,7 +21,7 @@ class Config:
     and provides methods to access the settings.
     """
 
-    def __init__(self, config_file: str = 'py_ddns.ini') -> None:
+    def __init__(self, config_file: str = "py_ddns.ini") -> None:
         """
         Initializes the Config class and loads the configuration file.
         """
@@ -32,25 +34,26 @@ def setup_logging(self) -> None:
         """
         Sets up the logging configuration for the application.
         """
-        logging_level = self.config.get('Client_settings', 'logging_level')
+        logging_level = self.config.get("Client_settings", "logging_level")
 
-        if logging_level.lower().strip() not in ['info', 'debug']:
+        if logging_level.lower().strip() not in ["info", "debug"]:
             raise ValueError(
-                f"Invalid logging level.  Expected info or logging, got {logging_level}"
+                "Invalid logging level."
+                f"Expected info or logging, got {logging_level}"
             )
 
-        if logging_level.lower() == 'debug':
+        if logging_level.lower() == "debug":
             level = logging.DEBUG
         else:
             level = logging.INFO
 
         logging.basicConfig(
-            level= level,
-            format='%(asctime)s - %(levelname)s - %(message)s',
+            level=level,
+            format="%(asctime)s - %(levelname)s - %(message)s",
             handlers=[
-                logging.FileHandler('py_ddns.log'),
-                logging.StreamHandler()
-            ]
+                logging.FileHandler("py_ddns.log"),
+                logging.StreamHandler(),
+            ],
         )
         logging.info("Logging is set up, level = %s", logging_level.upper())
 
@@ -60,7 +63,9 @@ def load_config(self) -> None:
         """
 
         if not os.path.exists(self.config_file):
-            raise FileNotFoundError(f"Configuration file '{self.config_file}' not found.")
+            raise FileNotFoundError(
+                f"Configuration file '{self.config_file}' not found."
+            )
 
         self.config.read(self.config_file)
 

src/pyddns/services/__init__.py

@@ -0,0 +1,5 @@
+"""
+Services Module
+
+This module provides integration for various DNS service providers
+"""