umnetdb-utils 0.1.4__tar.gz → 0.2.0__tar.gz

{umnetdb_utils-0.1.4 → umnetdb_utils-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umnetdb-utils
-Version: 0.1.4
+Version: 0.2.0
 Summary: Helper classes for querying UMnet databases
 License: MIT
 Author: Amy Liebowitz
@@ -16,6 +16,7 @@ Requires-Dist: oracledb (>=3.1.0,<4.0.0)
 Requires-Dist: psycopg[binary] (>=3.2.9,<4.0.0)
 Requires-Dist: python-decouple (>=3.8,<4.0)
 Requires-Dist: sqlalchemy (>=2.0.41,<3.0.0)
+Requires-Dist: typer (>=0.16.0,<0.17.0)
 Description-Content-Type: text/markdown
 
 # umnetdb-utils

{umnetdb_utils-0.1.4 → umnetdb_utils-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "umnetdb-utils"
-version = "0.1.4"
+version = "0.2.0"
 description = "Helper classes for querying UMnet databases"
 authors = [
     {name = "Amy Liebowitz",email = "amylieb@umich.edu"}
@@ -12,9 +12,13 @@ dependencies = [
     "sqlalchemy (>=2.0.41,<3.0.0)",
     "oracledb (>=3.1.0,<4.0.0)",
     "psycopg[binary] (>=3.2.9,<4.0.0)",
-    "python-decouple (>=3.8,<4.0)"
+    "python-decouple (>=3.8,<4.0)",
+    "typer (>=0.16.0,<0.17.0)"
 ]
 
+[project.scripts]
+umnetdb='umnetdb_utils.cli:main'
+
 [tool.poetry]
 
 [tool.poetry.group.dev.dependencies]

{umnetdb_utils-0.1.4 → umnetdb_utils-0.2.0}/umnetdb_utils/__init__.py

@@ -1,4 +1,4 @@
 from .umnetequip import UMnetequip
 from .umnetinfo import UMnetinfo
 from .umnetdisco import Umnetdisco
-from .umnetdb import UMnetdb
+from .umnetdb import UMnetdb

{umnetdb_utils-0.1.4 → umnetdb_utils-0.2.0}/umnetdb_utils/base.py

@@ -1,4 +1,3 @@
-
 from typing import Union
 from os import getenv
 import re
@@ -10,14 +9,16 @@ from sqlalchemy.orm import Session
 
 logger = logging.getLogger(__name__)
 
+
 class UMnetdbBase:
     """
     Base helper class
     """
+
     # set in child classes - you can use environment variables within curly braces here
     URL = None
 
-    def __init__(self, env_file:str=".env"):
+    def __init__(self, env_file: str = ".env"):
         """
         Initiate a umnetdb object. Optionally provide a path to a file with environment variables
         containing the credentials for the database. If no file is provided and there's no ".env",
@@ -73,14 +74,24 @@ class UMnetdbBase:
     def __exit__(self, fexc_type, exc_val, exc_tb):
         self.close()
 
-    def __getattr__(self, val:str):
+    def __getattr__(self, val: str):
         if self.session:
             return getattr(self.session, val)
 
         raise AttributeError(self)
 
-    def _build_select(self, select, table, joins=None, where=None, order_by=None, limit=None, group_by=None, distinct=False) -> str:
-        '''
+    def _build_select(
+        self,
+        select,
+        table,
+        joins=None,
+        where=None,
+        order_by=None,
+        limit=None,
+        group_by=None,
+        distinct=False,
+    ) -> str:
+        """
         Generic 'select' query string builder built from standard query components as input.
         The user is required to generate substrings for the more complex inputs
         (eg joins, where statements), this function just puts all the components
@@ -93,7 +104,7 @@ class UMnetdbBase:
           ex: "node_ip nip"
         :joins: a list of strings representing join statements. Include the actual 'join' part!
           ex: ["join node n on nip.mac = n.mac", "join device d on d.ip = n.switch"]
-        :where: For a single where statement, provide a string. For multiple provide a list. 
+        :where: For a single where statement, provide a string. For multiple provide a list.
            The list of statements are "anded". If you need "or", embed it in one of your list items
            DO NOT provide the keyword 'where' - it is auto-added.
           ex: ["node_ip.ip = '1.2.3.4'", "node.switch = '10.233.0.5'"]
@@ -101,10 +112,10 @@ class UMnetdbBase:
         :group_by: A string representing a column name (or names) to group by
         :limit: An integer
 
-        '''
+        """
 
         # First part of the sql statement is the 'select'
-        distinct = 'distinct ' if distinct else ''
+        distinct = "distinct " if distinct else ""
         sql = f"select {distinct}" + ", ".join(select) + "\n"
 
         # Next is the table
@@ -118,7 +129,6 @@ class UMnetdbBase:
 
         # Next are the filters. They are 'anded'
         if where and isinstance(where, list):
-            
             sql += "where\n"
             sql += " and\n".join(where) + "\n"
         elif where:
@@ -133,20 +143,20 @@ class UMnetdbBase:
 
         if limit:
             sql += f"limit {limit}\n"
-        
+
         logger.debug(f"Generated SQL command:\n****\n{sql}\n****\n")
 
         return sql
 
-    def _execute(self, sql:str, rows_as_dict:bool=True, fetch_one:bool=False):
-        '''
+    def _execute(self, sql: str, rows_as_dict: bool = True, fetch_one: bool = False):
+        """
         Generic sqlalchemy "open a session, execute this sql command and give me all the results"
 
         NB This function is defined for legacy database classes that came from umnet-scripts.
         It's encouraged to use "self.session.execute" in other child methods, allowing
         scripts that import the child class to use the context manager and execute multiple
         mehtods within the same session.
-        '''
+        """
         with self.engine.begin() as c:
             r = c.execute(text(sql))
 
@@ -158,8 +168,9 @@ class UMnetdbBase:
         else:
             return []
 
-        
-    def execute(self, sql:str, rows_as_dict:bool=True, fetch_one:bool=False) -> Union[list[dict],dict]:
+    def execute(
+        self, sql: str, rows_as_dict: bool = True, fetch_one: bool = False
+    ) -> Union[list[dict], dict]:
         """
         Executes a sqlalchemy command and gives all the results as a list of dicts, or as a dict
         if 'fetch_one' is set to true.
@@ -172,5 +183,5 @@ class UMnetdbBase:
 
         if fetch_one:
             return dict(result.fetchone())
-        
-        return [dict(r) for r in result.fetchall()]
+
+        return [dict(r) for r in result.fetchall()]

umnetdb_utils-0.2.0/umnetdb_utils/cli.py

@@ -0,0 +1,114 @@
+import typer
+from umnetdb_utils import UMnetdb
+import inspect
+from functools import wraps
+
+from rich.console import Console
+from rich.table import Table
+
+from typing import Callable, List
+from typing_extensions import Annotated
+
+app = typer.Typer()
+
+def print_result(result:List[dict]):
+    """
+    Takes the result of a umnetdb call and prints it as a table
+    """
+    if len(result) == 0:
+        print("No results found")
+        return
+    
+    if isinstance(result, dict):
+        result = [result]
+        
+    # instantiate table with columns based on entry dict keys
+    table = Table(*result[0].keys())
+    for row in result:
+        table.add_row(*[str(i) for i in row.values()])
+
+    console = Console()
+    console.print(table)
+    
+
+def command_generator(method_name:str, method:Callable):
+    """
+    Generates a typer command function for an arbitrary method
+    in the umnetdb class. The generated function opens a connection with 
+    the database, executes the method, and prints out the results.
+
+    Note that the docstring of each method is interrogated to generate
+    help text for each typer command.
+
+    :method_name: The name of the method
+    :method: The method itself
+    """
+
+    # first we're going to tease out the 'help' portions of the method
+    # from the docstring.
+    docstr = method.__doc__
+    docstr_parts = docstr.split("\n:")
+
+    # first section of the docstring is always a generic 'this is what the method does'.
+    cmd_help = docstr_parts.pop(0)
+
+    # next sections are details on the specific arguments that we want to pass to typer as
+    # special annotated type hints
+    arg_help = {}
+    for arg_str in docstr_parts:
+        if ":" in arg_str:
+            arg, help = arg_str.split(":")
+            arg_help[arg] = help.strip()
+        
+    sig = inspect.signature(method)
+
+    # going through the method's arguments and augmenting the 'help' section for each one
+    # from the docstring if applicable
+    new_params = []
+    for p_name, p in sig.parameters.items():
+
+        # need to skip self
+        if p_name == "self":
+            continue
+
+        # if there wasn't any helper text then just append the parameter as is
+        if p_name not in arg_help:
+            new_params.append(p)
+            continue
+
+        # params without default values should be typer 'arguments'
+        if p.default == inspect._empty:
+            new_params.append(p.replace(annotation=Annotated[p.annotation, typer.Argument(help=arg_help[p_name])]))
+            continue
+
+        # params with default values should be typer 'options'
+        new_params.append(p.replace(annotation=Annotated[p.annotation, typer.Option(help=arg_help[p_name])]))
+
+    new_sig = sig.replace(parameters=new_params)
+
+
+    # new munged function based on the origional method, with a new signature
+    # and docstring for typer
+    @wraps(method)
+    def wrapper(*args, **kwargs):
+        with UMnetdb() as db:
+            result = getattr(db, method_name)(*args, **kwargs)
+        print_result(result)
+    
+    wrapper.__signature__ = new_sig
+    wrapper.__doc__ = cmd_help
+
+    return wrapper
+
+
+def main():
+    for f_name,f in UMnetdb.__dict__.items():
+        if not(f_name.startswith("_")) and callable(f):
+            app.command()(command_generator(f_name, f))
+
+    app()
+
+if __name__ == "__main__":
+    main()
+
+