Improve error reporting and table generation

vultron/cmd.py

@@ -1,20 +1,32 @@
+import inspect
 import os
 import vultron.api
+import vultron.display
+import vultron.err
 
-class CmdNotFound(Exception):
+class CmdNotFound(vultron.err.Error):
   def __str__(self):
-    return f"error: command not found: {self.args[0]}"
+    return f"command not found: {self.args[0]}"
 
-class NoApiKey(Exception):
+class FeatureMissing(vultron.err.Error):
-  # FIXME: __str__ message
+  def __str__(self):
-  pass
+    return f"feature not yet implemented: {self.args[0]}"
 
-class FeatureMissing(Exception):
+class NoApiKey(vultron.err.Error):
-  # FIXME: __str__ message
+  def __str__(self):
-  pass
+    return f"no api key provided"
 
-# FIXME: Move command execution into Command class, so wrapper can do pre/post
+class NotEnoughArgs(vultron.err.Error):
-# work.
+  def __str__(self):
+    name = self.args[0]
+    more = self.args[1]
+
+    if self.args[1] > 1:
+      return f"sub-command requires {more} more arguments: {name}"
+    else:
+      return f"sub-command requires 1 more argument: {name}"
+
+# FIXME: Handle paging
 class Command:
   """A nop Vultron command. This feature is not implemented yet."""
 
@@ -33,8 +45,19 @@ class Command:
 
     self.api = vultron.api.Client(api_key)
 
-  def init(self):
+  def exec_shortcut(self, shortcut, *args):
-    pass
+    fn = self.find(shortcut)
+    sig = inspect.signature(fn)
+
+    if len(args) < len(sig.parameters):
+      name = fn.__name__[len(self.FTR_PRFX):].lower()
+      raise NotEnoughArgs(name, len(sig.parameters) - len(args))
+
+    data = fn(*args)
+
+    if data is not None:
+      display = vultron.display.FORMATS[self.out](data)
+      print(display.render())
 
   def find(self, name):
     needle = f"{self.FTR_PRFX}{name}".lower()
@@ -51,7 +74,10 @@ class Command:
 
     raise CmdNotFound(name)
 
-  def vultron_help(self, *args):
+  def init(self):
+    pass
+
+  def vultron_help(self):
     """This help message."""
 
     prog = os.path.basename(self.prog)

vultron/cmds/account.py

@@ -1,4 +1,5 @@
 import vultron.cmd
+import vultron.display
 
 class Account(vultron.cmd.Command):
   """Query for account information."""
@@ -7,6 +8,4 @@ class Account(vultron.cmd.Command):
     """Display your account details."""
 
     account = self.api.get("account")
-    display = vultron.display.render(self.out, [account["account"]])
+    return [account["account"]]
-
-    print(display)

vultron/cmds/help.py

@@ -1,4 +1,5 @@
 import vultron.cmd
+import vultron.display
 
 class Help(vultron.cmd.Command):
   def init(self):

vultron/cmds/region.py

@@ -1,10 +1,18 @@
 import vultron.cmd
+import vultron.display
 
 class Region(vultron.cmd.Command):
   """Query for information on Vultr regions."""
 
-  def vultron_list(self, *args):
+  def vultron_list(self):
-    regions = self.api.get("regions")
+    """Display all available regions."""
-    display = vultron.display.render(self.out, regions["regions"])
 
-    print(display)
+    regions = self.api.get("regions")
+    return regions["regions"]
+
+  def vultron_plan(self, region_id):
+    """Display available plans for a given region."""
+
+    plans = self.api.get("regions", region_id, "availability")
+    table = [{"plan": plan} for plan in plans["available_plans"]]
+    return table

vultron/cmds/vpc.py

@@ -1,4 +1,5 @@
 import vultron.cmd
+import vultron.display
 
 class Vpc(vultron.cmd.Command):
   """Query for information on VPCs."""
@@ -7,6 +8,4 @@ class Vpc(vultron.cmd.Command):
     """Display all VPCs."""
 
     vpcs = self.api.get("vpcs")
-    display = vultron.display.render(self.out, vpcs["vpcs"])
+    return vpcs["vpcs"]
-
-    print(display)

vultron/display.py

@@ -1,99 +1,125 @@
-# FIXME: Make this whole package less fragile
+class OutFormat:
-TYPES = ["tbl", "chrt", "csv", "json"]
+  def __init__(self, data):
+    self.spans = { }
+    self.rows = [ ]
 
-def wall(len, fill="\u2501"):
+    for row in data:
-  return fill * len
+      vals = { }
 
-# FIXME: normalize/analyze table data before building for optimization
+      for field in row:
-def table(data):
+        vals[field] = self.normalize(row[field])
-  lens = dict()
 
-  for row in data:
+        if field in self.spans:
-    for col in row:
+          self.spans[field] = max(self.spans[field], len(vals[field]))
-      col_len = len(col)
+        else:
-      val_len = len(str(row[col]))
+          self.spans[field] = max(len(field), len(vals[field]))
-      max_len = 0
 
-      if col in lens:
+      self.rows.append(vals)
-        max_len = lens[col]
 
-      lens[col] = max(col_len, val_len, max_len)
+    self.cols = list(self.spans.keys())
 
-  col_hdrs = [{"column": col_hdr, "length": lens[col_hdr]} for col_hdr in lens]
+  def normalize(self, field):
-  out = f"\u250F{wall(col_hdrs[0]['length'] + 2)}"
+    if type(field) == list:
-
+      return ", ".join(field)
-  for col_hdr in col_hdrs[1:]:
-    out += f"\u2533{wall(col_hdr['length'] + 2)}"
-
-  out += "\u2513\n"
-
-  for col_hdr in col_hdrs:
-    out += f"\u2503 {col_hdr['column'].ljust(col_hdr['length'])} "
-
-  out += f"\u2503\n\u2523{wall(col_hdrs[0]['length'] + 2)}"
-
-  for col_hdr in col_hdrs[1:]:
-    out += f"\u254B{wall(col_hdr['length'] + 2)}"
-
-  out += "\u252B\n"
-
-  for row in data[:-1]:
-    for col_hdr in col_hdrs:
-      out += "\u2503 "
-
-      if col_hdr["column"] in row:
-        out += str(row[col_hdr["column"]]).ljust(col_hdr["length"])
-      else:
-        out += " " * col_hdr["length"]
-
-      out += " "
-
-    out += f"\u2503\n\u2523{wall(col_hdrs[0]['length'] + 2)}"
-
-    for col_hdr in col_hdrs[1:]:
-      out += f"\u254B{wall(col_hdr['length'] + 2)}"
-
-    out += "\u252B\n"
-
-  for col_hdr in col_hdrs:
-    out += "\u2503 "
-
-    if col_hdr["column"] in data[-1]:
-      out += str(data[-1][col_hdr["column"]]).ljust(col_hdr["length"])
     else:
-      out += " " * col_hdr["length"]
+      return str(field)
 
-    out += " "
+  def render(self):
+    # FIXME: consider if this should do anything
+    pass
 
-  out += "\u2503\n"
+class Basic(OutFormat):
+  def __init__(self, data):
+    super().__init__(data)
 
-  out += f"\u2517{wall(col_hdrs[0]['length'] + 2)}"
+    self.top = {
+      "left": "+", "right": "+",
+      "divide": "+", "fill": "-"
+    }
 
-  for col_hdr in col_hdrs[1:]:
+    self.base = {
-    out += f"\u253B{wall(col_hdr['length'] + 2)}"
+      "left": "+", "right": "+",
+      "divide": "+", "fill": "-"
+    }
 
-  out += "\u251B"
+    self.sep = {
+      "left": "|", "right": "|",
+      "divide": "+", "fill": "-"
+    }
 
-  return out
+    self.row = {
+      "left": "|", "right": "|",
+      "divide": "|", "fill": " "
+    }
 
-def chrt(data):
+  def render(self):
-  return data
+    sep = ""
+    top = ""
+    hdr = ""
+    base = ""
+    fill = self.row["fill"]
 
-def csv(data):
+    for col in self.cols:
-  return data
+      width = self.spans[col] + 2
+      sep += self.sep["divide"] + self.sep["fill"] * width
+      top += self.top["divide"] + self.top["fill"] * width
+      hdr += self.row["divide"] + fill + col.ljust(width - 1, fill)
+      base += self.base["divide"] + self.base["fill"] * width
 
-def json(data):
+    sep = self.sep["left"] + sep[1:] + self.sep["right"] + "\n"
-  return data
+    top = self.top["left"] + top[1:] + self.top["right"] + "\n"
+    hdr = self.row["left"] + hdr[1:] + self.row["right"] + "\n"
+    base = self.base["left"] + base[1:] + self.base["right"]
+    lines = [ ]
 
-def render(out, data):
+    for row in self.rows:
-  # FIXME: option to pipe into pager, cut off at max column, squeeze, or do
+      line = ""
-  # nothing (depends on TTY/PAGER)
+
-  if out == "tbl":
+      for col in self.cols:
-    return table(data)
+        width = self.spans[col] + 2
-  elif out == "chrt":
+
-    return chart(data)
+        if col in row:
-  elif out == "csv":
+          line += self.row["divide"] + fill + row[col].ljust(width - 1, fill)
-    return csv(data)
+        else:
-  elif out == "json":
+          line += slef.row["divide"] + fill * width
-    return json(data)
+
-  # FIXME: error unrecognized out format
+      lines.append(self.row["left"] + line[1:] + self.row["right"] + "\n")
+
+    return top + sep.join([hdr, *lines]) + base
+
+class Table(Basic):
+  def __init__(self, data):
+    super().__init__(data)
+
+    self.top = {
+      "left": "\u250F", "right": "\u2513",
+      "divide": "\u2533", "fill": "\u2501"
+    }
+
+    self.base = {
+      "left": "\u2517", "right": "\u251B",
+      "divide": "\u253B", "fill": "\u2501"
+    }
+
+    self.sep = {
+      "left": "\u2523", "right": "\u252B",
+      "divide": "\u254B", "fill": "\u2501"
+    }
+
+    self.row = {
+      "left": "\u2503", "right": "\u2503",
+      "divide": "\u2503", "fill": " "
+    }
+
+class Json(OutFormat):
+  pass
+
+class Csv(OutFormat):
+  pass
+
+FORMATS = {
+  "basic": Basic,
+  "table": Table,
+  "json": Json,
+  "csv": Csv
+}

vultron/err.py

@@ -0,0 +1,4 @@
+class Error(Exception):
+  def __str__(self):
+    # FIXME: should show full traceback?
+    return f"something went wrong: {self.args}"

vultron/vultron.py

@@ -3,13 +3,15 @@ import os
 import sys
 import vultron.cmd
 import vultron.display
+import vultron.err
 
 from vultron.cmds import *
 
 @click.command()
 @click.option("--help", is_flag=True)
 @click.option("--api-key", type=str)
-@click.option("--out", type=click.Choice(vultron.display.TYPES), default="tbl")
+@click.option("--out",
+  type=click.Choice(vultron.display.FORMATS.keys()), default="table")
 @click.argument("args", nargs=-1)
 # FIXME: click should not show any help messages
 def app(help, api_key, out, args):
@@ -34,9 +36,7 @@ def app(help, api_key, out, args):
     else:
       shortcut = vultron_api.default
 
-    vultron_fn = vultron_api.find(shortcut)
+    vultron_api.exec_shortcut(shortcut, *args)
-    vultron_fn(*args)
+  except vultron.err.Error as err:
-  except vultron.cmd.CmdNotFound as err:
+    print(f"error: {err}", file=sys.stderr)
-    # FIXME: Base Vultron error class
-    print(err, file=sys.stderr)
     # FIXME: Activate help command