Merge pull request #507 from linode/dev

Release v5.42.0

Author: zliang-akamai

.pylintrc

@@ -422,6 +422,8 @@ disable=raw-checker-failed,
         invalid-name,
         fixme,
         duplicate-code,
+        too-few-public-methods,
+        too-many-instance-attributes,
         use-symbolic-message-instead
 
 # Enable the message, report, category or checker with the given id(s). You can

README.rst

@@ -266,6 +266,8 @@ This can be done using the following environment variables to override certain s
 
 * ``LINODE_CLI_API_SCHEME`` - The request scheme to use (e.g. ``https``)
 
+Alternatively, these values can be configured per-user using the ``linode-cli configure`` command.
+
 Multiple Users
 ^^^^^^^^^^^^^^
 

linodecli/__init__.py

@@ -26,9 +26,7 @@
 from .completion import bake_completions, get_completions
 from .configuration import ENV_TOKEN_NAME
 from .helpers import handle_url_overrides
-from .operation import CLIArg, CLIOperation, URLParam
 from .output import OutputMode
-from .response import ModelAttr, ResponseModel
 
 # this might not be installed at the time of building
 try:
@@ -102,6 +100,7 @@ def main():  # pylint: disable=too-many-branches,too-many-statements
 
     cli.output_handler.suppress_warnings = parsed.suppress_warnings
     cli.output_handler.disable_truncation = parsed.no_truncation
+    cli.output_handler.column_width = parsed.column_width
 
     if parsed.as_user and not skip_config:
         cli.config.set_user(parsed.as_user)

linodecli/api_request.py

@@ -2,17 +2,47 @@
 This module is responsible for handling HTTP requests to the Linode API.
 """
 
+import itertools
 import json
 import sys
 from sys import version_info
-from typing import Optional
+from typing import Iterable, List, Optional
 
 import requests
 from packaging import version
 from requests import Response
 
 from linodecli.helpers import API_CA_PATH
 
+from .baked.operation import ExplicitNullValue, OpenAPIOperation
+from .helpers import handle_url_overrides
+
+
+def get_all_pages(ctx, operation: OpenAPIOperation, args: List[str]):
+    """
+    Receive all pages of a resource from multiple
+    API responses then merge into one page.
+
+    :param ctx: The main CLI object
+    """
+
+    ctx.page_size = 500
+    ctx.page = 1
+    result = do_request(ctx, operation, args).json()
+
+    total_pages = result.get("pages")
+
+    if total_pages and total_pages > 1:
+        pages_needed = range(2, total_pages + 1)
+
+        result = _merge_results_data(
+            itertools.chain(
+                (result,),
+                _generate_all_pages_results(ctx, operation, args, pages_needed),
+            )
+        )
+    return result
+
 
 def do_request(
     ctx,
@@ -26,7 +56,10 @@ def do_request(
     """
     Makes a request to an operation's URL and returns the resulting JSON, or
     prints and error if a non-200 comes back
+
+    :param ctx: The main CLI object
     """
+    # TODO: Revisit using pre-built calls from OpenAPI
     method = getattr(requests, operation.method)
     headers = {
         "Authorization": f"Bearer {ctx.config.get_token()}",
@@ -67,6 +100,39 @@ def do_request(
     return result
 
 
+def _merge_results_data(results: Iterable[dict]):
+    """Merge multiple json response into one"""
+
+    iterator = iter(results)
+    merged_result = next(iterator, None)
+    if not merged_result:
+        return None
+
+    if "pages" in merged_result:
+        merged_result["pages"] = 1
+    if "page" in merged_result:
+        merged_result["page"] = 1
+    if "data" in merged_result:
+        merged_result["data"] += list(
+            itertools.chain.from_iterable(r["data"] for r in iterator)
+        )
+    return merged_result
+
+
+def _generate_all_pages_results(
+    ctx,
+    operation: OpenAPIOperation,
+    args: List[str],
+    pages_needed: Iterable[int],
+):
+    """
+    :param ctx: The main CLI object
+    """
+    for p in pages_needed:
+        ctx.page = p
+        yield do_request(ctx, operation, args).json()
+
+
 def _build_filter_header(
     operation, parsed_args, filter_header=None
 ) -> Optional[str]:
@@ -84,6 +150,10 @@ def _build_filter_header(
         if p.name in parsed_args_dict:
             del parsed_args_dict[p.name]
 
+    # check for order-by and order
+    order_by = parsed_args_dict.pop("order_by")
+    order = parsed_args_dict.pop("order") or "asc"
+
     # The "+and" list to be used in the filter header
     filter_list = []
 
@@ -95,14 +165,27 @@ def _build_filter_header(
         new_filters = [{k: j} for j in v] if isinstance(v, list) else [{k: v}]
         filter_list.extend(new_filters)
 
+    result = {}
     if len(filter_list) > 0:
-        return json.dumps({"+and": filter_list})
-
-    return None
+        if len(filter_list) == 1:
+            result = filter_list[0]
+        else:
+            result["+and"] = filter_list
+    if order_by is not None:
+        result["+order_by"] = order_by
+        result["+order"] = order
+    return json.dumps(result) if len(result) > 0 else None
 
 
 def _build_request_url(ctx, operation, parsed_args) -> str:
-    result = operation.url.format(**vars(parsed_args))
+    target_server = handle_url_overrides(
+        operation.url_base,
+        host=ctx.config.get_value("api_host"),
+        version=ctx.config.get_value("api_version"),
+        scheme=ctx.config.get_value("api_scheme"),
+    )
+
+    result = f"{target_server}{operation.url_path}".format(**vars(parsed_args))
 
     if operation.method == "get":
         result += f"?page={ctx.page}&page_size={ctx.page_size}"
@@ -121,7 +204,19 @@ def _build_request_body(ctx, operation, parsed_args) -> Optional[str]:
             parsed_args, operation.allowed_defaults, operation.action
         )
 
-    to_json = {k: v for k, v in vars(parsed_args).items() if v is not None}
+    to_json = {}
+
+    for k, v in vars(parsed_args).items():
+        # Skip null values
+        if v is None:
+            continue
+
+        # Explicitly include ExplicitNullValues
+        if isinstance(v, ExplicitNullValue):
+            to_json[k] = None
+            continue
+
+        to_json[k] = v
 
     expanded_json = {}
 

linodecli/arg_helpers.py

@@ -126,6 +126,13 @@ def register_args(parser):
         default=False,
         help="Prevent the truncation of long values in command outputs.",
     )
+    parser.add_argument(
+        "--column-width",
+        type=int,
+        default=None,
+        help="Sets the maximum width of each column in outputted tables. "
+        "By default, columns are dynamically sized to fit the terminal.",
+    )
     parser.add_argument(
         "--version",
         "-v",
@@ -341,35 +348,37 @@ def action_help(cli, command, action):
         return
     print(f"linode-cli {command} {action}", end="")
     for param in op.params:
-        # clean up parameter names - we add an '_' at the end of them
-        # during baking if it conflicts with the name of an argument.
         pname = param.name.upper()
-        if pname[-1] == "_":
-            pname = pname[:-1]
         print(f" [{pname}]", end="")
     print()
     print(op.summary)
     if op.docs_url:
         print(f"API Documentation: {op.docs_url}")
     print()
+    if op.method == "get" and op.action == "list":
+        filterable_attrs = [
+            attr for attr in op.response_model.attrs if attr.filterable
+        ]
+
+        if filterable_attrs:
+            print("You may filter results with:")
+            for attr in filterable_attrs:
+                print(f"  --{attr.name}")
+            print(
+                "Additionally, you may order results using --order-by and --order."
+            )
+        return
     if op.args:
         print("Arguments:")
         for arg in sorted(op.args, key=lambda s: not s.required):
+            if arg.read_only:
+                continue
             is_required = (
                 "(required) "
                 if op.method in {"post", "put"} and arg.required
                 else ""
             )
             print(f"  --{arg.path}: {is_required}{arg.description}")
-    elif op.method == "get" and op.action == "list":
-        filterable_attrs = [
-            attr for attr in op.response_model.attrs if attr.filterable
-        ]
-
-        if filterable_attrs:
-            print("You may filter results with:")
-            for attr in filterable_attrs:
-                print(f"  --{attr.name}")
 
 
 def bake_command(cli, spec_loc):

linodecli/baked/__init__.py

@@ -0,0 +1,4 @@
+"""
+Collection of classes for handling the parsed OpenAPI Spec for the CLI
+"""
+from .operation import OpenAPIOperation

linodecli/baked/colors.py

@@ -0,0 +1,53 @@
+"""
+Applies shell color escapes for pretty printing
+"""
+import os
+import platform
+
+DO_COLORS = True
+# !! Windows compatibility for ANSI color codes !!
+#
+# If we're running on windows, we need to run the "color" command to enable
+# ANSI color code support.
+if platform.system() == "Windows":
+    ver = platform.version()
+
+    if "." in ver:
+        ver = ver.split(".", 1)[0]
+
+    try:
+        verNum = int(ver)
+    except ValueError:
+        DO_COLORS = False
+
+    # windows 10+ supports ANSI color codes after running the 'color' command to
+    # properly set up the command prompt.  Older versions of windows do not, and
+    # we should not attempt to use them there.
+    if verNum >= 10:
+        os.system("color")
+    else:
+        DO_COLORS = False
+
+
+CLEAR_COLOR = "\x1b[0m"
+COLOR_CODE_MAP = {
+    "red": "\x1b[31m",
+    "green": "\x1b[32m",
+    "yellow": "\x1b[33m",
+    "black": "\x1b[30m",
+    "white": "\x1b[40m",
+}
+
+
+def colorize_string(string, color):
+    """
+    Returns the requested string, wrapped in ANSI color codes to colorize it as
+    requested.  On platforms where colors are not supported, this just returns
+    the string passed into it.
+    """
+    if not DO_COLORS:
+        return string
+
+    col = COLOR_CODE_MAP.get(color, CLEAR_COLOR)
+
+    return f"{col}{string}{CLEAR_COLOR}"