Add connection check before starting rendering

Author: pedjaradenkovic

codeplain_REST_api.py

@@ -14,6 +14,17 @@
     "LLMInternalError",
 ]
 
+# Mapping from API error codes to exception classes
+ERROR_CODE_EXCEPTIONS = {
+    "FunctionalRequirementTooComplex": plain2code_exceptions.FunctionalRequirementTooComplex,
+    "ConflictingRequirements": plain2code_exceptions.ConflictingRequirements,
+    "CreditBalanceTooLow": plain2code_exceptions.CreditBalanceTooLow,
+    "LLMInternalError": plain2code_exceptions.LLMInternalError,
+    "MissingResource": plain2code_exceptions.MissingResource,
+    "PlainSyntaxError": plain2code_exceptions.PlainSyntaxError,
+    "InternalServerError": plain2code_exceptions.InternalServerError,
+}
+
 
 class CodeplainAPI:
 
@@ -33,13 +44,31 @@ def _extend_payload_with_run_state(self, payload: dict, run_state: RunState):
         run_state.increment_call_count()
         payload["render_state"] = run_state.to_dict()
 
-    def post_request(self, endpoint_url, headers, payload, run_state: Optional[RunState]):  # noqa: C901
+    def _raise_for_error_code(self, response_json):
+        """Raise appropriate exception based on error code in response."""
+        error_code = response_json.get("error_code")
+        if error_code not in ERROR_CODE_EXCEPTIONS:
+            return
+
+        exception_class = ERROR_CODE_EXCEPTIONS[error_code]
+        message = response_json.get("message", "")
+
+        # FunctionalRequirementTooComplex has an extra parameter
+        if error_code == "FunctionalRequirementTooComplex":
+            raise exception_class(message, response_json.get("proposed_breakdown"))
+
+        raise exception_class(message)
+
+    def post_request(
+        self, endpoint_url, headers, payload, run_state: Optional[RunState], num_retries: int = MAX_RETRIES
+    ):
         if run_state is not None:
             self._extend_payload_with_run_state(payload, run_state)
 
         retry_delay = RETRY_DELAY
         response_json = None
-        for attempt in range(MAX_RETRIES + 1):
+
+        for attempt in range(num_retries + 1):
             try:
                 response = requests.post(endpoint_url, headers=headers, json=payload)
 
@@ -50,28 +79,7 @@ def post_request(self, endpoint_url, headers, payload, run_state: Optional[RunSt
                     raise
 
                 if response.status_code == requests.codes.bad_request and "error_code" in response_json:
-                    if response_json["error_code"] == "FunctionalRequirementTooComplex":
-                        raise plain2code_exceptions.FunctionalRequirementTooComplex(
-                            response_json["message"], response_json.get("proposed_breakdown")
-                        )
-
-                    if response_json["error_code"] == "ConflictingRequirements":
-                        raise plain2code_exceptions.ConflictingRequirements(response_json["message"])
-
-                    if response_json["error_code"] == "CreditBalanceTooLow":
-                        raise plain2code_exceptions.CreditBalanceTooLow(response_json["message"])
-
-                    if response_json["error_code"] == "LLMInternalError":
-                        raise plain2code_exceptions.LLMInternalError(response_json["message"])
-
-                    if response_json["error_code"] == "MissingResource":
-                        raise plain2code_exceptions.MissingResource(response_json["message"])
-
-                    if response_json["error_code"] == "PlainSyntaxError":
-                        raise plain2code_exceptions.PlainSyntaxError(response_json["message"])
-
-                    if response_json["error_code"] == "InternalServerError":
-                        raise plain2code_exceptions.InternalServerError(response_json["message"])
+                    self._raise_for_error_code(response_json)
 
                 response.raise_for_status()
                 return response_json
@@ -81,16 +89,24 @@ def post_request(self, endpoint_url, headers, payload, run_state: Optional[RunSt
                     if response_json["error_code"] not in RETRY_ERROR_CODES:
                         raise e
 
-                if attempt < MAX_RETRIES:
-                    self.console.info(f"Error on attempt {attempt + 1}/{MAX_RETRIES + 1}: {e}")
+                if attempt < num_retries:
+                    self.console.info(f"Error on attempt {attempt + 1}/{num_retries + 1}: {e}")
                     self.console.info(f"Retrying in {retry_delay} seconds...")
                     time.sleep(retry_delay)
-                    # Exponential backoff
-                    retry_delay *= 2
+                    retry_delay *= 2  # Exponential backoff
                 else:
-                    self.console.error(f"Max retries ({MAX_RETRIES}) exceeded. Last error: {e}")
+                    self.console.error(f"Max retries ({num_retries}) exceeded. Last error: {e}")
                     raise e
 
+    def connection_check(self, client_version):
+        endpoint_url = f"{self.api_url}/connection_check"
+        headers = {"Content-Type": "application/json"}
+        payload = {
+            "api_key": self.api_key,
+            "client_version": client_version,
+        }
+        return self.post_request(endpoint_url, headers, payload, None, num_retries=0)
+
     def render_functional_requirement(
         self,
         frid: str,

config/system_config.yaml

@@ -1,3 +1,5 @@
+client_version: "0.17.0"
+
 system_requirements:
   timeout:
     command: timeout

plain2code.py

@@ -21,11 +21,13 @@
     ConflictingRequirements,
     CreditBalanceTooLow,
     InternalServerError,
+    InvalidAPIKey,
     InvalidFridArgument,
     LLMInternalError,
     MissingAPIKey,
     MissingPreviousFunctionalitiesError,
     MissingResource,
+    OutdatedClientVersion,
     PlainSyntaxError,
     UnexpectedState,
 )
@@ -163,6 +165,25 @@ def setup_logging(
     root_logger.info(f"Render ID: {render_id}")  # Ensure render ID is logged in to codeplain.log file
 
 
+def _check_connection(codeplainAPI):
+    """Check API connectivity and validate API key and client version."""
+    response = codeplainAPI.connection_check(system_config.client_version)
+
+    if not response.get("api_key_valid", False):
+        raise InvalidAPIKey(
+            "Provided API key is invalid. Please provide a valid API key using the CODEPLAIN_API_KEY environment variable "
+            "or the --api-key argument."
+        )
+
+    if not response.get("client_version_valid", False):
+        min_version = response.get("min_client_version", "unknown")
+        raise OutdatedClientVersion(
+            f"Your client version ({system_config.client_version}) is outdated. Minimum required version is {min_version}. "
+            "Please update using:"
+            "  uv tool upgrade codeplain"
+        )
+
+
 def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # noqa: C901
     # Check system requirements before proceeding
     system_config.verify_requirements()
@@ -187,6 +208,8 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
     assert args.api is not None and args.api != "", "API URL is required"
     codeplainAPI.api_url = args.api
 
+    _check_connection(codeplainAPI)
+
     module_renderer = ModuleRenderer(
         codeplainAPI,
         args.filename,
@@ -266,6 +289,10 @@ def main():  # noqa: C901
         console.debug(f"Render ID: {run_state.render_id}")
     except MissingAPIKey as e:
         console.error(f"Missing API key: {str(e)}\n")
+    except InvalidAPIKey as e:
+        console.error(f"Invalid API key: {str(e)}\n")
+    except OutdatedClientVersion as e:
+        console.error(f"Outdated client version: {str(e)}\n")
     except (InternalServerError, UnexpectedState):
         exc_info = sys.exc_info()
         console.error(

plain2code_exceptions.py

@@ -33,6 +33,14 @@ class MissingAPIKey(Exception):
     pass
 
 
+class InvalidAPIKey(Exception):
+    pass
+
+
+class OutdatedClientVersion(Exception):
+    pass
+
+
 class InvalidFridArgument(Exception):
     pass
 

system_config.py

@@ -12,11 +12,14 @@ class SystemConfig:
 
     def __init__(self):
         self.config = self._load_config()
+        if "client_version" not in self.config:
+            raise KeyError("Missing 'client_version' in system_config.yaml")
         if "system_requirements" not in self.config:
             raise KeyError("Missing 'system_requirements' section in system_config.yaml")
         if "error_messages" not in self.config:
             raise KeyError("Missing 'error_messages' section in system_config.yaml")
 
+        self.client_version = self.config["client_version"]
         self.requirements = self.config["system_requirements"]
         self.error_messages = self.config["error_messages"]
 

tui/components.py

@@ -41,12 +41,9 @@ def get_max_label_width(active_types: list["ScriptOutputType"]) -> int:
             return 0
         return max(len(script_type.value) for script_type in active_types)
 
-    def get_padded_label(self, active_types: list["ScriptOutputType"]) -> str:
+    def get_padded_label(self) -> str:
         """Get the label left-aligned (no padding).
 
-        Args:
-            active_types: List of ScriptOutputType enum members that are currently active
-
         Returns:
             Label without padding (left-aligned)
         """