refactor: improve code readability with more descriptive naming (#133)

backend/apps/common/__init__.py

@@ -8,11 +8,13 @@
 log = logging.getLogger(__name__)
 
 
-def create_app(name=__name__, static_folder="static", cfg: config.Config = None):
+def create_app(
+    name=__name__, static_folder="static", configuration: config.Config = None
+):
     """Create the WSGI app."""
-    cfg = config.Config() if cfg is None else cfg
+    configuration = config.Config() if configuration is None else configuration
 
-    app = base.create_app(name, static_folder, cfg)
+    app = base.create_app(name, static_folder, configuration)
 
     # Register the app's blueprints
     app.register_blueprint(routes_bp)

backend/apps/common/routes/delete.py

@@ -12,12 +12,14 @@
     "/api/namespaces/<namespace>/inferenceservices/<inference_service>",
     methods=["DELETE"],
 )
-def delete_inference_service(inference_service, namespace):
+def delete_inference_service(namespace, inference_service):
     """Handle DELETE requests and delete the provided InferenceService."""
-    log.info("Deleting InferenceService %s/%s'", namespace, inference_service)
-    gvk = versions.inference_service_gvk()
-    api.delete_custom_rsrc(**gvk, name=inference_service, namespace=namespace)
+    log.info("Deleting InferenceService %s/%s", namespace, inference_service)
+    group_version_kind = versions.inference_service_group_version_kind()
+    api.delete_custom_rsrc(
+        **group_version_kind, name=inference_service, namespace=namespace
+    )
     return api.success_response(
         "message",
-        "InferenceService %s/%s successfully deleted." % (namespace, inference_service),
+        f"InferenceService {namespace}/{inference_service} successfully deleted.",
     )

backend/apps/common/routes/get.py

@@ -12,18 +12,20 @@
 
 @bp.route("/api/namespaces/<namespace>/inferenceservices")
 def get_inference_services(namespace):
-    """Return a list of InferenceService CRs as json objects."""
-    gvk = versions.inference_service_gvk()
-    inference_services = api.list_custom_rsrc(**gvk, namespace=namespace)
+    """Return a list of InferenceService custom resources as JSON objects."""
+    group_version_kind = versions.inference_service_group_version_kind()
+    inference_services = api.list_custom_rsrc(**group_version_kind, namespace=namespace)
 
     return api.success_response("inferenceServices", inference_services["items"])
 
 
 @bp.route("/api/namespaces/<namespace>/inferenceservices/<name>")
 def get_inference_service(namespace, name):
-    """Return an InferenceService CR as a json object."""
+    """Return an InferenceService custom resource as a JSON object."""
     inference_service = api.get_custom_rsrc(
-        **versions.inference_service_gvk(), namespace=namespace, name=name
+        **versions.inference_service_group_version_kind(),
+        namespace=namespace,
+        name=name,
     )
     if request.args.get("logs", "false") == "true":
         # find the logs
@@ -39,74 +41,84 @@ def get_inference_service(namespace, name):
     return api.success_response("inferenceService", inference_service)
 
 
-def get_inference_service_logs(svc):
-    """Return all logs for all isvc component pods."""
-    namespace = svc["metadata"]["namespace"]
+def get_inference_service_logs(inference_service):
+    """Return logs for each InferenceService component pod."""
+    namespace = inference_service["metadata"]["namespace"]
     components = request.args.getlist("component")
 
     log.info(components)
 
     # Check deployment mode to determine how to get logs
-    deployment_mode = utils.get_deployment_mode(svc)
+    deployment_mode = utils.get_deployment_mode(inference_service)
 
     if deployment_mode == "ModelMesh":
         # For ModelMesh, get logs from modelmesh-serving deployment
-        component_pods_dict = utils.get_modelmesh_pods(svc, components)
+        component_pods_dict = utils.get_modelmesh_pods(inference_service, components)
     elif deployment_mode == "RawDeployment":
-        component_pods_dict = utils.get_raw_inference_service_pods(svc, components)
+        component_pods_dict = utils.get_raw_inference_service_pods(
+            inference_service, components
+        )
     else:
         # Serverless mode
-        component_pods_dict = utils.get_inference_service_pods(svc, components)
+        component_pods_dict = utils.get_inference_service_pods(
+            inference_service, components
+        )
 
     if len(component_pods_dict.keys()) == 0:
         return {}
 
-    resp = {}
-    logging.info("Component pods: %s", component_pods_dict)
+    logs_by_component = {}
+    log.info("Component pods: %s", component_pods_dict)
     for component, pods in component_pods_dict.items():
-        if component not in resp:
-            resp[component] = []
+        if component not in logs_by_component:
+            logs_by_component[component] = []
 
         for pod in pods:
             logs = api.get_pod_logs(namespace, pod, "kserve-container", auth=False)
-            resp[component].append({"podName": pod, "logs": logs.split("\n")})
-    return resp
+            logs_by_component[component].append(
+                {"podName": pod, "logs": logs.split("\n")}
+            )
+    return logs_by_component
 
 
 @bp.route("/api/namespaces/<namespace>/knativeServices/<name>")
 def get_knative_service(namespace, name):
-    """Return a Knative Services object as json."""
-    svc = api.get_custom_rsrc(
+    """Return a Knative Service object as JSON."""
+    service = api.get_custom_rsrc(
         **versions.KNATIVE_SERVICE, namespace=namespace, name=name
     )
 
-    return api.success_response("knativeService", svc)
+    return api.success_response("knativeService", service)
 
 
 @bp.route("/api/namespaces/<namespace>/configurations/<name>")
 def get_knative_configuration(namespace, name):
-    """Return a Knative Configurations object as json."""
-    svc = api.get_custom_rsrc(**versions.KNATIVE_CONF, namespace=namespace, name=name)
+    """Return a Knative Configuration object as JSON."""
+    configuration = api.get_custom_rsrc(
+        **versions.KNATIVE_CONFIGURATION, namespace=namespace, name=name
+    )
 
-    return api.success_response("knativeConfiguration", svc)
+    return api.success_response("knativeConfiguration", configuration)
 
 
 @bp.route("/api/namespaces/<namespace>/revisions/<name>")
 def get_knative_revision(namespace, name):
-    """Return a Knative Revision object as json."""
-    svc = api.get_custom_rsrc(
+    """Return a Knative Revision object as JSON."""
+    revision = api.get_custom_rsrc(
         **versions.KNATIVE_REVISION, namespace=namespace, name=name
     )
 
-    return api.success_response("knativeRevision", svc)
+    return api.success_response("knativeRevision", revision)
 
 
 @bp.route("/api/namespaces/<namespace>/routes/<name>")
 def get_knative_route(namespace, name):
-    """Return a Knative Route object as json."""
-    svc = api.get_custom_rsrc(**versions.KNATIVE_ROUTE, namespace=namespace, name=name)
+    """Return a Knative Route object as JSON."""
+    route = api.get_custom_rsrc(
+        **versions.KNATIVE_ROUTE, namespace=namespace, name=name
+    )
 
-    return api.success_response("knativeRoute", svc)
+    return api.success_response("knativeRoute", route)
 
 
 @bp.route("/api/namespaces/<namespace>/inferenceservices/<name>/events")
@@ -125,27 +137,33 @@ def get_inference_service_events(namespace, name):
 # RawDeployment mode endpoints
 @bp.route("/api/namespaces/<namespace>/deployments/<name>")
 def get_kubernetes_deployment(namespace, name):
-    """Return a Kubernetes Deployment object as json."""
+    """Return a Kubernetes Deployment object as JSON."""
     deployment = api.get_custom_rsrc(
-        **versions.K8S_DEPLOYMENT, namespace=namespace, name=name
+        **versions.KUBERNETES_DEPLOYMENT_RESOURCE,
+        namespace=namespace,
+        name=name,
     )
     return api.success_response("deployment", deployment)
 
 
 @bp.route("/api/namespaces/<namespace>/services/<name>")
 def get_kubernetes_service(namespace, name):
-    """Return a Kubernetes Service object as json."""
+    """Return a Kubernetes Service object as JSON."""
     service = api.get_custom_rsrc(
-        **versions.K8S_SERVICE, namespace=namespace, name=name
+        **versions.KUBERNETES_SERVICE_RESOURCE,
+        namespace=namespace,
+        name=name,
     )
     return api.success_response("service", service)
 
 
 @bp.route("/api/namespaces/<namespace>/hpas/<name>")
 def get_kubernetes_hpa(namespace, name):
-    """Return a Kubernetes HPA object as json."""
-    hpa = api.get_custom_rsrc(**versions.K8S_HPA, namespace=namespace, name=name)
-    return api.success_response("hpa", hpa)
+    """Return a Kubernetes HorizontalPodAutoscaler object as JSON."""
+    horizontal_pod_autoscaler = api.get_custom_rsrc(
+        **versions.KUBERNETES_HPA_RESOURCE, namespace=namespace, name=name
+    )
+    return api.success_response("hpa", horizontal_pod_autoscaler)
 
 
 @bp.route(
@@ -155,7 +173,9 @@ def get_raw_deployment_objects(namespace, name, component):
     """Return all Kubernetes native resources for a RawDeployment component."""
 
     inference_service = api.get_custom_rsrc(
-        **versions.inference_service_gvk(), namespace=namespace, name=name
+        **versions.inference_service_group_version_kind(),
+        namespace=namespace,
+        name=name,
     )
 
     if not utils.is_raw_deployment(inference_service):
@@ -172,7 +192,9 @@ def get_modelmesh_objects(namespace, name, component):
     """Return all ModelMesh-specific resources for a ModelMesh component."""
 
     inference_service = api.get_custom_rsrc(
-        **versions.inference_service_gvk(), namespace=namespace, name=name
+        **versions.inference_service_group_version_kind(),
+        namespace=namespace,
+        name=name,
     )
 
     if not utils.is_modelmesh_deployment(inference_service):