code cleanup

Author: tmeiczin

src/reliqua/api.py

@@ -65,7 +65,7 @@ def __init__(
         :param dict info:                     Application information
         :param dict openapi:                  OpenAPI configuration options
 
-        :return:                               api instance
+        :return:                               API instance
         """
         info = info or {}
         openapi = openapi or {}
@@ -107,6 +107,7 @@ def __init__(
         self._add_docs()
 
     def _add_handlers(self):
+        """Add custom media handlers."""
         extra_handlers = {
             "application/yaml": YAMLHandler(),
             "text/html; charset=utf-8": TextHandler(),
@@ -118,6 +119,7 @@ def _add_handlers(self):
         self.resp_options.media_handlers.update(extra_handlers)
 
     def _load_resources(self):
+        """Load resource classes from the specified resource path."""
         resources = []
         path = f"{self.resource_path}/*.py"
         print(f"searching {path}")
@@ -128,10 +130,11 @@ def _load_resources(self):
             classes = self._get_classes(file)
             resources.extend(classes)
 
-        # add config to resource
+        # Add config to resource
         self.resources = [x(app_config=self.config, **self.resource_attributes) for x in resources]
 
     def _is_route_method(self, name, suffix):
+        """Check if a method name is a route method."""
         if not name.startswith("on_"):
             return None
 
@@ -141,6 +144,7 @@ def _is_route_method(self, name, suffix):
         return re.search(r"^on_([a-z]+)$", name)
 
     def _parse_methods(self, resource, route, methods):
+        """Parse methods of a resource for a given route."""
         parser = SphinxParser()
         for name in methods:
             operation_id = f"{resource.__class__.__name__}.{name}"
@@ -149,23 +153,30 @@ def _parse_methods(self, resource, route, methods):
             resource.__data__[route][action] = parser.parse(method, operation_id=operation_id)
 
     def _parse_resource(self, resource):
+        """Parse a resource to extract routes and methods."""
         for route, data in resource.__routes__.items():
             resource.__data__[route] = {}
             suffix = data.get("suffix", None)
             methods = [x for x in dir(resource) if self._is_route_method(x, suffix)]
             self._parse_methods(resource, route, methods)
 
     def _parse_docstrings(self):
+        """Parse docstrings of all resources."""
         for resource in self.resources:
             resource.__data__ = {}
             self._parse_resource(resource)
 
     def _get_classes(self, filename):
+        """Get resource classes from a file."""
         classes = []
         module_name = str(uuid.uuid3(uuid.NAMESPACE_OID, filename))
         spec = importlib.util.spec_from_file_location(module_name, filename)
         module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            print(f"Error loading module {module_name}: {e}")
+            return classes
 
         for _, c in inspect.getmembers(module, inspect.isclass):
             if issubclass(c, Resource) and hasattr(c, "__routes__"):
@@ -174,12 +185,14 @@ def _get_classes(self, filename):
         return classes
 
     def _add_routes(self):
+        """Add routes for all resources."""
         for resource in self.resources:
             routes = resource.__routes__
             for route, kwargs in routes.items():
                 self.add_route(route, resource, **kwargs)
 
     def _add_docs(self):
+        """Add Swagger and OpenAPI documentation routes."""
         swagger = Swagger(
             self.openapi["static_url"],
             self.openapi["spec_url"],

src/reliqua/app.py

@@ -43,18 +43,19 @@
 
 def update_dict(a, b):
     """
-    Update dictionary A with values from dictionary B.
+    Update dictionary a with values from dictionary b.
 
-    Update the diction A with values from dictionary B. Remove
-    keys from A that are not in B.
+    Update dictionary a with values from dictionary b. Remove
+    keys from a that are not in b.
 
-    :param dict a:    Dictionary A
-    :param dict b:    Dictionary B
+    :param dict a:  Dictionary to update
+    :param dict b:  Dictionary with new values
+    :return dict:   Updated dictionary
     """
-    # Create a new dictionary with keys from A that are also in B
+    # Create a new dictionary with keys from a that are also in b
     updated_dict = {key: a[key] for key in a if key in b}
 
-    # Add keys from B that are not in A
+    # Add keys from b that are not in a
     for key in b:
         if key not in updated_dict:
             updated_dict[key] = b[key]
@@ -78,8 +79,9 @@ def load_config(config_file):
 
         for option in config.options(section):
             params[option] = config.get(section, option)
-    except TypeError:
-        pass
+    except (TypeError, configparser.Error) as e:
+        # Log the error or handle it appropriately
+        print(f"Error loading config file: {e}")
 
     return params
 
@@ -125,7 +127,7 @@ def __init__(
 
         middleware.append(ProcessParams())
 
-        # trim slashes from proxy URL if specified; otherwise set default proxy url
+        # Trim slashes from proxy URL if specified; otherwise set default proxy URL
         bind = self.gunicorn_options["bind"]
         openapi["api_url"] = openapi["api_url"].rstrip("/") if openapi["api_url"] else f"http://{bind}"
 

src/reliqua/openapi.py

@@ -115,7 +115,7 @@ def __init__(
         self.examples = examples
         self._datatype = datatype
 
-        # path parameters are always required
+        # Path parameters are always required
         if self.location == "path":
             self.required = True
 
@@ -125,7 +125,7 @@ def datatype(self):
         value = self._datatype
         a, _, b = value.partition("|")
 
-        # handle defined list type ex: list[str]
+        # Handle defined list type ex: list[str]
         if re.search(r"list\[(\w+)]", a):
             a = "list"
 

src/reliqua/swagger.py

@@ -13,7 +13,13 @@ def index(spec, server, sort="alpha", highlight="true"):
     """
     Return the Swagger index HTML.
 
-    This returns the Swagger index html contents.
+    This returns the Swagger index HTML contents.
+
+    :param str spec:       URL to the OpenAPI spec
+    :param str server:     URL to the server hosting Swagger UI assets
+    :param str sort:       Sort order for operations and tags
+    :param str highlight:  Enable syntax highlighting
+    :return str:           HTML content for Swagger UI
     """
     highlight = "true" if highlight else "false"
 
@@ -60,7 +66,7 @@ def index(spec, server, sort="alpha", highlight="true"):
 
 
 class Swagger(Resource):
-    """Class to server the static swagger files."""
+    """Class to serve the static Swagger files."""
 
     no_auth = True
 
@@ -70,24 +76,21 @@ def __init__(self, url, openapi_url, sort="alpha", highlight=True):
 
         :param str url:            URL to Swagger instance
         :param str openapi_url:    URL to OpenAPI spec
-        :param srt sort:           Tag/Endpoint sort order
+        :param str sort:           Tag/Endpoint sort order
         :param bool highlight:     Syntax highlighting
-        :param bool authenticate:  Docs need authentication
-        :return:                   None
         """
+        super().__init__()
         self.url = url
         self.openapi_url = openapi_url
         self.highlight = highlight
         self.sort = sort
 
     def on_get(self, _req, resp):
         """
-        Return the static swagger file.
+        Return the static Swagger file.
 
-        :param Request request:     Request object
-        :param Response response:   Response object
-        :param str filename:        Filename contents to return
-        :return text:               File contents
+        :param Request _req:       Request object
+        :param Response resp:      Response object
         """
         resp.status = HTTP(200)
         resp.content_type = "text/html"