Merge branch 'dev' into add_db_config_tests

Author: ykim-akamai

linodecli/api_request.py

@@ -23,6 +23,7 @@
     ExplicitNullValue,
     OpenAPIOperation,
 )
+from .baked.util import get_path_segments
 from .helpers import handle_url_overrides
 
 if TYPE_CHECKING:
@@ -364,13 +365,15 @@ def _build_request_body(
         if v is None or k in param_names:
             continue
 
+        path_segments = get_path_segments(k)
+
         cur = expanded_json
-        for part in k.split(".")[:-1]:
+        for part in path_segments[:-1]:
             if part not in cur:
                 cur[part] = {}
             cur = cur[part]
 
-        cur[k.split(".")[-1]] = v
+        cur[path_segments[-1]] = v
 
     return json.dumps(_traverse_request_body(expanded_json))
 

linodecli/baked/operation.py

@@ -25,6 +25,7 @@
     OpenAPIRequestArg,
 )
 from linodecli.baked.response import OpenAPIResponse
+from linodecli.baked.util import unescape_arg_segment
 from linodecli.exit_codes import ExitCodes
 from linodecli.output.output_handler import OutputHandler
 from linodecli.overrides import OUTPUT_OVERRIDES
@@ -649,6 +650,9 @@ def _add_args_post_put(
             if arg.read_only:
                 continue
 
+            arg_name_unescaped = unescape_arg_segment(arg.name)
+            arg_path_unescaped = unescape_arg_segment(arg.path)
+
             arg_type = (
                 arg.item_type if arg.datatype == "array" else arg.datatype
             )
@@ -660,15 +664,17 @@ def _add_args_post_put(
             if arg.datatype == "array":
                 # special handling for input arrays
                 parser.add_argument(
-                    "--" + arg.path,
-                    metavar=arg.name,
+                    "--" + arg_path_unescaped,
+                    dest=arg.path,
+                    metavar=arg_name_unescaped,
                     action=ArrayAction,
                     type=arg_type_handler,
                 )
             elif arg.is_child:
                 parser.add_argument(
-                    "--" + arg.path,
-                    metavar=arg.name,
+                    "--" + arg_path_unescaped,
+                    dest=arg.path,
+                    metavar=arg_name_unescaped,
                     action=ListArgumentAction,
                     type=arg_type_handler,
                 )
@@ -677,7 +683,7 @@ def _add_args_post_put(
                 if arg.datatype == "string" and arg.format == "password":
                     # special case - password input
                     parser.add_argument(
-                        "--" + arg.path,
+                        "--" + arg_path_unescaped,
                         nargs="?",
                         action=PasswordPromptAction,
                     )
@@ -687,15 +693,17 @@ def _add_args_post_put(
                     "ssl-key",
                 ):
                     parser.add_argument(
-                        "--" + arg.path,
-                        metavar=arg.name,
+                        "--" + arg_path_unescaped,
+                        dest=arg.path,
+                        metavar=arg_name_unescaped,
                         action=OptionalFromFileAction,
                         type=arg_type_handler,
                     )
                 else:
                     parser.add_argument(
-                        "--" + arg.path,
-                        metavar=arg.name,
+                        "--" + arg_path_unescaped,
+                        dest=arg.path,
+                        metavar=arg_name_unescaped,
                         type=arg_type_handler,
                     )
 

linodecli/baked/request.py

@@ -9,7 +9,10 @@
 
 from linodecli.baked.parsing import simplify_description
 from linodecli.baked.response import OpenAPIResponse
-from linodecli.baked.util import _aggregate_schema_properties
+from linodecli.baked.util import (
+    _aggregate_schema_properties,
+    escape_arg_segment,
+)
 
 
 class OpenAPIRequestArg:
@@ -152,6 +155,8 @@ def _parse_request_model(
         return args
 
     for k, v in properties.items():
+        k = escape_arg_segment(k)
+
         # Handle nested objects which aren't read-only and have properties
         if (
             v.type == "object"

linodecli/baked/util.py

@@ -2,8 +2,9 @@
 Provides various utility functions for use in baking logic.
 """
 
+import re
 from collections import defaultdict
-from typing import Any, Dict, Set, Tuple
+from typing import Any, Dict, List, Set, Tuple
 
 from openapi3.schemas import Schema
 
@@ -51,3 +52,58 @@ def _handle_schema(_schema: Schema):
         # We only want to mark fields that are required by ALL subschema as required
         set(key for key, count in required.items() if count == schema_count),
     )
+
+
+ESCAPED_PATH_DELIMITER_PATTERN = re.compile(r"(?<!\\)\.")
+
+
+def escape_arg_segment(segment: str) -> str:
+    """
+    Escapes periods in a segment by prefixing them with a backslash.
+
+    :param segment: The input string segment to escape.
+    :return: The escaped segment with periods replaced by '\\.'.
+    """
+    return segment.replace(".", "\\.")
+
+
+def unescape_arg_segment(segment: str) -> str:
+    """
+    Reverses the escaping of periods in a segment, turning '\\.' back into '.'.
+
+    :param segment: The input string segment to unescape.
+    :return: The unescaped segment with '\\.' replaced by '.'.
+    """
+    return segment.replace("\\.", ".")
+
+
+def get_path_segments(path: str) -> List[str]:
+    """
+    Splits a path string into segments using a delimiter pattern,
+    and unescapes any escaped delimiters in the resulting segments.
+
+    :param path: The full path string to split and unescape.
+    :return: A list of unescaped path segments.
+    """
+    return [
+        unescape_arg_segment(seg)
+        for seg in ESCAPED_PATH_DELIMITER_PATTERN.split(path)
+    ]
+
+
+def get_terminal_keys(data: Dict[str, Any]) -> List[str]:
+    """
+    Recursively retrieves all terminal (non-dict) keys from a nested dictionary.
+
+    :param data: The input dictionary, possibly nested.
+    :return: A list of all terminal keys (keys whose values are not dictionaries).
+    """
+    ret = []
+
+    for k, v in data.items():
+        if isinstance(v, dict):
+            ret.extend(get_terminal_keys(v))  # recurse into nested dicts
+        else:
+            ret.append(k)  # terminal key
+
+    return ret

linodecli/output/output_handler.py

@@ -16,6 +16,7 @@
 from rich.table import Column, Table
 
 from linodecli.baked.response import OpenAPIResponse, OpenAPIResponseAttr
+from linodecli.baked.util import get_terminal_keys
 
 
 class OutputMode(Enum):
@@ -328,15 +329,30 @@ def _json_output(self, header, data, to):
         Prints data in JSON format
         """
         # Special handling for JSON headers.
-        # We're only interested in the last part of the column name.
-        header = [v.split(".")[-1] for v in header]
+        # We're only interested in the last part of the column name, unless the last
+        # part is a dotted key. If the last part is a dotted key, include the entire dotted key.
 
         content = []
         if len(data) and isinstance(data[0], dict):  # we got delimited json in
+            parsed_header = []
+            terminal_keys = get_terminal_keys(data[0])
+
+            for v in header:
+                parts = v.split(".")
+                if (
+                    len(parts) >= 2
+                    and ".".join([parts[-2], parts[-1]]) in terminal_keys
+                ):
+                    parsed_header.append(".".join([parts[-2], parts[-1]]))
+                else:
+                    parsed_header.append(parts[-1])
+
             # parse down to the value we display
             for row in data:
-                content.append(self._select_json_elements(header, row))
+                content.append(self._select_json_elements(parsed_header, row))
         else:  # this is a list
+            header = [v.split(".")[-1] for v in header]
+
             for row in data:
                 content.append(dict(zip(header, row)))
 

linodecli/overrides.py

@@ -47,6 +47,30 @@ def inner(func):
     return inner
 
 
+@output_override("databases", "mysql-config-view", OutputMode.table)
+def handle_databases_mysql_config_view(
+    operation, output_handler, json_data
+) -> bool:
+    # pylint: disable=unused-argument
+    """
+    Override the output of 'linode-cli databases mysql-config-view'
+    to properly display the mysql engine config.
+    """
+    return databases_mysql_config_view_output(json_data)
+
+
+@output_override("databases", "postgres-config-view", OutputMode.table)
+def handle_databases_postgres_config_view(
+    operation, output_handler, json_data
+) -> bool:
+    # pylint: disable=unused-argument
+    """
+    Override the output of 'linode-cli databases postgres-config-view'
+    to properly display the postgresql engine config.
+    """
+    return databases_postgres_config_view_output(json_data)
+
+
 @output_override("domains", "zone-file", OutputMode.delimited)
 def handle_domains_zone_file(operation, output_handler, json_data) -> bool:
     # pylint: disable=unused-argument
@@ -291,3 +315,97 @@ def pg_view_output(json_data) -> bool:
     console.print(output)
 
     return False
+
+
+def add_param_row(output, param_name, param_data):
+    """
+    Construct and add a row to the output table for DB Config view overrides.
+    """
+    param_type = str(param_data.get("type", ""))
+    example = str(param_data.get("example", ""))
+    minimum = str(param_data.get("minimum", ""))
+    maximum = str(param_data.get("maximum", ""))
+    min_length = str(param_data.get("minLength", ""))
+    max_length = str(param_data.get("maxLength", ""))
+    pattern = str(param_data.get("pattern", ""))
+    requires_restart = "YES" if param_data.get("requires_restart") else "NO"
+    description = param_data.get("description", "")
+
+    output.add_row(
+        param_name,
+        param_type,
+        example,
+        minimum,
+        maximum,
+        min_length,
+        max_length,
+        pattern,
+        requires_restart,
+        Align(description, align="left"),
+    )
+
+
+def databases_mysql_config_view_output(json_data) -> bool:
+    """
+    Parse and format the MySQL configuration output table.
+    """
+    output = Table(header_style="bold", show_lines=True)
+
+    output.add_column("Parameter", style="bold")
+    output.add_column("Type", justify="center")
+    output.add_column("Example", justify="center")
+    output.add_column("Min", justify="center")
+    output.add_column("Max", justify="center")
+    output.add_column("Min Length", justify="center")
+    output.add_column("Max Length", justify="center")
+    output.add_column("Pattern", justify="center")
+    output.add_column("Requires Restart", justify="center")
+    output.add_column("Description", style="dim")
+
+    for field, params in json_data.items():
+        if field in ["binlog_retention_period"]:
+            add_param_row(output, field, params)
+        else:
+            for key, val in params.items():
+                param_name = f"{field}.{key}"
+                add_param_row(output, param_name, val)
+
+    console = Console()
+    console.print(output)
+
+    return False
+
+
+def databases_postgres_config_view_output(json_data) -> bool:
+    """
+    Parse and format the PostgreSQL configuration output table.
+    """
+    output = Table(header_style="bold", show_lines=True)
+
+    output.add_column("Parameter", style="bold")
+    output.add_column("Type", justify="center")
+    output.add_column("Example", justify="center")
+    output.add_column("Min", justify="center")
+    output.add_column("Max", justify="center")
+    output.add_column("Min Length", justify="center")
+    output.add_column("Max Length", justify="center")
+    output.add_column("Pattern", justify="center")
+    output.add_column("Requires Restart", justify="center")
+    output.add_column("Description", style="dim")
+
+    for field, params in json_data.items():
+        if field in [
+            "pg_stat_monitor_enable",
+            "shared_buffers_percentage",
+            "work_mem",
+        ]:
+            add_param_row(output, field, params)
+        else:
+            for key, val in params.items():
+                param_name = f"{field}.{key}"
+                add_param_row(output, param_name, val)
+
+    console = Console()
+    console.print(output)
+
+    return False