umnetdb-utils 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

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/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/umnetdb.py

@@ -1,4 +1,3 @@
-
 from typing import List
 import logging
 import re
@@ -9,12 +8,9 @@ from .base import UMnetdbBase
 
 
 class UMnetdb(UMnetdbBase):
+    URL = "postgresql+psycopg://{UMNETDB_USER}:{UMNETDB_PASSWORD}@wintermute.umnet.umich.edu/umnetdb"
 
-    URL="postgresql+psycopg://{UMNETDB_USER}:{UMNETDB_PASSWORD}@wintermute.umnet.umich.edu/umnetdb"
-
-    def get_neighbors(
-        self, device: str, known_devices_only: bool = True
-    ) -> List[dict]:
+    def get_neighbors(self, device: str, known_devices_only: bool = True) -> List[dict]:
         """
         Gets a list of the neighbors of a particular device. If the port
         has a parent in the LAG table that is included as well.
@@ -35,12 +31,12 @@ class UMnetdb(UMnetdbBase):
                 "n_d.name as remote_device",
                 "n.remote_port",
                 "l.parent",
-                "n_l.parent as remote_parent"
-                ]
+                "n_l.parent as remote_parent",
+            ]
             joins = [
-             "join device n_d on n_d.hostname=n.remote_device",
-             "left outer join lag l on l.device=n.device and l.member=n.port",
-             "left outer join lag n_l on n_l.device=n_d.name and n_l.member=n.remote_port",
+                "join device n_d on n_d.hostname=n.remote_device",
+                "left outer join lag l on l.device=n.device and l.member=n.port",
+                "left outer join lag n_l on n_l.device=n_d.name and n_l.member=n.remote_port",
             ]
         else:
             select = [
@@ -48,7 +44,7 @@ class UMnetdb(UMnetdbBase):
                 "coalesce(n_d.name, n.remote_device) as remote_device",
                 "n.remote_port",
                 "l.parent",
-                "n_l.parent as remote_parent"
+                "n_l.parent as remote_parent",
             ]
             joins = [
                 "left outer join device n_d on n_d.hostname=n.remote_device",
@@ -64,9 +60,7 @@ class UMnetdb(UMnetdbBase):
 
         return self.execute(query)
 
-    
-
-    def get_dlzone(self, zone_name:str) -> List[dict]:
+    def get_dlzone(self, zone_name: str) -> List[dict]:
         """
         Gets all devices within a DL zone based on walking the 'neighbors'
         table.
@@ -77,42 +71,52 @@ class UMnetdb(UMnetdbBase):
         device_cols = ["name", "ip", "version", "vendor", "model", "serial"]
 
         # step 1 is to find DLs in the database - we'll seed our zone with them
-        query = self._build_select(select=device_cols, table="device",where=f"name similar to '(d-|dl-){zone_name}-(1|2)'")
+        query = self._build_select(
+            select=device_cols,
+            table="device",
+            where=f"name similar to '(d-|dl-){zone_name}-(1|2)'",
+        )
         dls = self.execute(query)
 
         if not dls:
             raise ValueError(f"No DLs found in umnetdb for zone {zone_name}")
 
-        devices_by_name = {d['name']:d for d in dls}
+        devices_by_name = {d["name"]: d for d in dls}
 
         # now we'll look for neighbors on each device within the zone.
         # Note that outside of the DLs we only expect to find devices that start with
         # "s-" anything else is considered 'outside the zone'
         todo = list(devices_by_name.keys())
-        while(len(todo) != 0):
-
+        while len(todo) != 0:
             device = todo.pop()
 
+            print(f"Processing device {device}")
             # note that by default this method only returns neighbors in the 'device' table,
             # any others are ignored
             neighs = self.get_neighbors(device)
             devices_by_name[device]["neighbors"] = {}
             for neigh in neighs:
-
-                # only want 'd- or 'dl-' or 's-' devices
-                if re.match(r"(dl?|s)-", neigh["remote_device"]):
-
+                print(f"EVALUATING {neigh}")
+                # only want 'd- or 'dl-' or 's-' devices, and we don't want out of band devices
+                if re.match(r"(dl?-|s-)", neigh["remote_device"]) and not re.match(
+                    r"s-oob-", neigh["remote_device"]
+                ):
                     # adding neighbor to local device's neighbor list
-                    devices_by_name[device]["neighbors"][neigh["port"]] = {k:v for k,v in neigh.items() if k != "port"}
+                    devices_by_name[device]["neighbors"][neigh["port"]] = {
+                        k: v for k, v in neigh.items() if k != "port"
+                    }
 
                     # if we haven't seen this neighbor yet, pull data from our device table for it, and
                     # add it to our 'to do' list to pull its neighbors.
                     if neigh["remote_device"] not in devices_by_name:
-
-                        query = self._build_select(select=device_cols, table="device", where=f"name = '{neigh['remote_device']}'")
+                        query = self._build_select(
+                            select=device_cols,
+                            table="device",
+                            where=f"name = '{neigh['remote_device']}'",
+                        )
                         neigh_device = self.execute(query, fetch_one=True)
                         devices_by_name[neigh_device["name"]] = neigh_device
-                
+
                         todo.append(neigh_device["name"])
 
         return list(devices_by_name.values())

umnetdb_utils/umnetdisco.py

@@ -1,24 +1,31 @@
-
-
 from .base import UMnetdbBase
 from .utils import is_ip_address, is_mac_address
 
 
 class Umnetdisco(UMnetdbBase):
-    URL="postgresql+psycopg://{NETDISCO_DB_USER}:{NETDISCO_DB_PASSWORD}@netdisco.umnet.umich.edu:5432/netdisco"
+    URL = "postgresql+psycopg://{NETDISCO_DB_USER}:{NETDISCO_DB_PASSWORD}@netdisco.umnet.umich.edu:5432/netdisco"
 
-    def host_arp(self, host, start_time=None, end_time=None, limit=1, active_only=False):
-        '''
-        Does an ARP query against the netdisco db for a single host. 
+    def host_arp(
+        self, host, start_time=None, end_time=None, limit=1, active_only=False
+    ):
+        """
+        Does an ARP query against the netdisco db for a single host.
         :host: A string representing a MAC address or an IPv4 address
-        '''
+        """
 
         # what table are we querying?
-        table = 'node_ip nip'
-        joins = ['join node n on nip.mac = n.mac']
+        table = "node_ip nip"
+        joins = ["join node n on nip.mac = n.mac"]
 
         # define select statements
-        select = ['nip.mac', 'nip.ip', 'n.switch', 'n.port', 'nip.time_first', 'nip.time_last']
+        select = [
+            "nip.mac",
+            "nip.ip",
+            "n.switch",
+            "n.port",
+            "nip.time_first",
+            "nip.time_last",
+        ]
 
         # First determine if this host is a MAC address or an IP
         where = []
@@ -31,7 +38,9 @@ class Umnetdisco(UMnetdbBase):
 
         # filter for specific start/end times if specified
         if start_time and end_time:
-            where.append(f"n.time_last between timestamp '{start_time}' and timestamp '{end_time}'")
+            where.append(
+                f"n.time_last between timestamp '{start_time}' and timestamp '{end_time}'"
+            )
         elif start_time:
             where.append(f"n.time_last > timestamp '{start_time}'")
 
@@ -40,63 +49,73 @@ class Umnetdisco(UMnetdbBase):
             where.append("nip.active = true")
 
         # order by last seen
-        sql = self._build_select(select, table, joins=joins, where=where, order_by="time_last", limit=limit)
+        sql = self._build_select(
+            select, table, joins=joins, where=where, order_by="time_last", limit=limit
+        )
         result = self._execute(sql)
 
         return result
 
     def arp_count(self, prefix=None, start_time=None, end_time=None, active_only=False):
-        '''
+        """
         Queries the host data in netdisco based on prefix and start/end time.
         First any prefix greater than or equal to the inputted prefix is searched for
         (in the 'device_ip' table).
 
         Then the host table is queried.
-        '''
-        
+        """
+
         # We're counting all the host IPs by subnet
-        select = ['count(distinct nip.ip)', 'dip.subnet']
-        table = 'node_ip nip'
+        select = ["count(distinct nip.ip)", "dip.subnet"]
+        table = "node_ip nip"
 
         # postgres allows us to do a join based on an IPs (type inet) membership
         # of a subnet (type cidr)
-        joins = ['join device_ip dip on nip.ip <<= dip.subnet']
+        joins = ["join device_ip dip on nip.ip <<= dip.subnet"]
 
         # grouping by subnet is what gives us per-subnet host counts
-        group_by = 'dip.subnet'
+        group_by = "dip.subnet"
 
         # append all cli filtering options
         where = [f"dip.subnet <<= inet '{prefix}'"]
         if start_time and end_time:
-            where.append(f"nip.time_last between timestamp '{start_time}' and timestamp '{end_time}'")
+            where.append(
+                f"nip.time_last between timestamp '{start_time}' and timestamp '{end_time}'"
+            )
         elif start_time:
             where.append(f"nip.time_last > timestamp '{start_time}'")
 
         if active_only:
             where.append("nip.active = true")
 
-        sql = self._build_select(select, table, joins=joins, where=where, group_by=group_by)
+        sql = self._build_select(
+            select, table, joins=joins, where=where, group_by=group_by
+        )
         return self._execute(sql)
 
     def neighbors(self, device=None):
-        '''
+        """
         Queries the device_ip table in netdisco to get neighbors of a device.
         If no device is specified, all neighbors are pulled.
         The device input can be an IPv4 address or an FQDN.
-        '''
-
-        select = [ 'dp.ip as local_ip',
-                   'ld.dns as local_dns',
-                   'dp.port as local_port',
-                   'dp.remote_ip',
-                   'rd.dns as remote_dns',
-                   'dp.remote_port']
-        table = 'device d'
-        joins = ['join device_port dp on d.ip = dp.ip',
-                 'join device ld on dp.ip = ld.ip',
-                 'join device rd on dp.remote_ip = rd.ip']
-
-        where = ['dp.remote_ip is not null']
+        """
+
+        select = [
+            "dp.ip as local_ip",
+            "ld.dns as local_dns",
+            "dp.port as local_port",
+            "dp.remote_ip",
+            "rd.dns as remote_dns",
+            "dp.remote_port",
+        ]
+        table = "device d"
+        joins = [
+            "join device_port dp on d.ip = dp.ip",
+            "join device ld on dp.ip = ld.ip",
+            "join device rd on dp.remote_ip = rd.ip",
+        ]
+
+        where = ["dp.remote_ip is not null"]
         if is_ip_address(device):
             where.append(f"d.ip = '{device}'")
         elif device:
@@ -106,37 +125,39 @@ class Umnetdisco(UMnetdbBase):
         return self._execute(sql)
 
     def get_devices(self, match_subnets=None, exclude_subnets=None):
-        '''
+        """
         Queries netdisco for a list of devices.
         Optionally, limit it by a list of prefixes
-        '''
+        """
 
-        select = [ 'ip', 'dns', 'serial', 'model', 'vendor', 'os' ]
-        table = 'device'
+        select = ["ip", "dns", "serial", "model", "vendor", "os"]
+        table = "device"
 
         where = []
         if match_subnets:
             where.append(" or\n".join([f"ip << inet '{s}'" for s in match_subnets]))
-        
+
         if exclude_subnets:
-            where.append("not\n" + " or\n".join([f"ip << inet '{s}'" for s in exclude_subnets]))
+            where.append(
+                "not\n" + " or\n".join([f"ip << inet '{s}'" for s in exclude_subnets])
+            )
 
         sql = self._build_select(select, table, where=where)
         return self._execute(sql)
 
     def get_device(self, name_or_ip):
-        '''
+        """
         Pulls the device name, ip, model, and description (where version info often is)
         from the netinfo device table
-        '''
+        """
         select = [
-                "replace(lower(name), '.umnet.umich.edu', '') as name",
-                "device.ip as ip",
-                "model",
-                "description",
-                ]
+            "replace(lower(name), '.umnet.umich.edu', '') as name",
+            "device.ip as ip",
+            "model",
+            "description",
+        ]
         table = "device"
-        
+
         if is_ip_address(name_or_ip):
             joins = ["join device_ip on device.ip=device_ip.alias"]
             where = [f"device_ip.alias='{name_or_ip}'"]
@@ -153,7 +174,7 @@ class Umnetdisco(UMnetdbBase):
             return None
 
     def get_port_and_host_data(self, name_or_ip):
-        '''
+        """
         Pulls a list of all ports on the switch and all hosts seen on those ports.
         You will see multiple rows for an interface where multiple hosts have been seen.
 
@@ -168,21 +189,21 @@ class Umnetdisco(UMnetdbBase):
         - vlan the host was seen on
         - date last mac was seen
 
-        '''
+        """
 
         # getting device by name or IP
         if is_ip_address(name_or_ip):
             device_ip = name_or_ip
         else:
             nd_device = self.get_device(name_or_ip)
-            if not(nd_device):
-                raise LookupError(f'Could not find {nd_device} in Netdisco')
-            device_ip = nd_device['ip']
+            if not (nd_device):
+                raise LookupError(f"Could not find {nd_device} in Netdisco")
+            device_ip = nd_device["ip"]
 
         # The port description is in different fields depending on the platform, so we need to do
         # some if-else stuff that's not supported in our basic sql builer in the base class.
         # That's why we're just doing a long sting here
-        sql = f'''
+        sql = f"""
 select
 dp.port,
 case
@@ -202,7 +223,7 @@ from device_port dp
 left outer join node on dp.port = node.port and dp.ip = node.switch
 left outer join node_ip on node.mac = node_ip.mac
 where dp.ip='{device_ip}'
-'''
+"""
 
         result = self._execute(sql)
 
@@ -210,7 +231,7 @@ where dp.ip='{device_ip}'
 
     def get_poe_data(self, name_or_ip):
         """
-        Pulls PoE admin, status, class, and power columns from device_port_pwer 
+        Pulls PoE admin, status, class, and power columns from device_port_pwer
         """
 
         # getting device by name or IP
@@ -218,16 +239,15 @@ where dp.ip='{device_ip}'
             device_ip = name_or_ip
         else:
             nd_device = self.get_device(name_or_ip)
-            if not(nd_device):
-                raise LookupError(f'Could not find {nd_device} in Netdisco')
-            device_ip = nd_device['ip']
-    
+            if not (nd_device):
+                raise LookupError(f"Could not find {nd_device} in Netdisco")
+            device_ip = nd_device["ip"]
+
         select = ["port", "admin", "status", "class", "power"]
         table = "device_port_power"
         where = [f"ip='{device_ip}'"]
 
-
         sql = self._build_select(select, table, where=where)
         result = self._execute(sql)
 
-        return result
+        return result

umnetdb_utils/umnetequip.py

@@ -3,25 +3,28 @@ from typing import Union, Optional
 from .base import UMnetdbBase
 from .utils import is_ip_address
 
+
 class UMnetequip(UMnetdbBase):
-    '''
+    """
     This class wraps helpful equip db queries in python.
-    '''
+    """
+
     URL = "oracle+oracledb://{EQUIP_DB_USERNAME}:{EQUIP_DB_PASSWORD}@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=equipdb-prod.umnet.umich.edu)(PORT=1521))(CONNECT_DATA=(SID=KANNADA)))"
 
     def get_devices_by_category(self, category, active_only=False):
-        '''
+        """
         Queries equip db for devices by category. You can also
         specify if you only want active devices.
-        '''
+        """
 
-        select = [ 'eq.monitored_device',
-                   'eq.rancid',
-                   'eq.off_line',
-                   'eq.dns_name',
-                   'eq.ip_address',
-                 ]
-        table = 'ARADMIN1.UMNET_EQUIPMENT eq'
+        select = [
+            "eq.monitored_device",
+            "eq.rancid",
+            "eq.off_line",
+            "eq.dns_name",
+            "eq.ip_address",
+        ]
+        table = "ARADMIN1.UMNET_EQUIPMENT eq"
 
         where = [f"eq.category = '{category}'"]
 
@@ -29,54 +32,55 @@ class UMnetequip(UMnetdbBase):
         # 1: RESERVE, 2:ACTIVE, 3:RETIRED
         if active_only:
             where.append("eq.status = 2")
-        
+
         sql = self._build_select(select, table, where=where, distinct=True)
         return self._execute(sql)
 
-
     def get_device_type(self, ip):
-        '''
+        """
         Queries equip db for a device by ip, returns the 'type' of the device.
         By type we mean the UMNET_EQUIPMENT_TYPE: ACCESS LAYER, DISTRIBUTION LAYER, UMD, etc
-        '''
-        select = [ 'types as type' ]
-        table = 'ARADMIN1.UMNET_EQUIPMENT'
+        """
+        select = ["types as type"]
+        table = "ARADMIN1.UMNET_EQUIPMENT"
         where = [f"ip_address='{ip}'"]
 
         sql = self._build_select(select, table, where=where)
         return self._execute(sql)
 
-    def get_devices_by_building_no(self, 
-                    building_no:Union[int, list],
-
-
-                    active_only:bool=False,
-                    types:Optional[list]=None,
-                    location_info:bool=False,
-                    ):
+    def get_devices_by_building_no(
+        self,
+        building_no: Union[int, list],
+        active_only: bool = False,
+        types: Optional[list] = None,
+        location_info: bool = False,
+    ):
         """
         Queries equipdb for devices by building no. You can provide a single
         building number, or a list of numbers. You can specify if you want 'active only' devices
         (based on the 'status' field, defalut false) or you can limit to a certain device type (default all).
         You can also get the location info for each device via 'location_info' (default false)
         """
-        select = [ 'dns_name',
-                   'ip_address',
-                   'model_no_ as model',
-                   'types as device_type', 
-                   'rancid',
-                   'off_line',         
-                 ]
+        select = [
+            "dns_name",
+            "ip_address",
+            "model_no_ as model",
+            "types as device_type",
+            "rancid",
+            "off_line",
+        ]
         if location_info:
-            select.extend([
-                    'bldg as building_name',
-                    'address as building_address',
-                    'room as room_no',
-                    'floor as floor',    
-                    'bldg_code__ as building_no',     
-            ])
-
-        table = 'ARADMIN1.UMNET_EQUIPMENT eq'
+            select.extend(
+                [
+                    "bldg as building_name",
+                    "address as building_address",
+                    "room as room_no",
+                    "floor as floor",
+                    "bldg_code__ as building_no",
+                ]
+            )
+
+        table = "ARADMIN1.UMNET_EQUIPMENT eq"
 
         where = []
         if isinstance(building_no, int):
@@ -99,59 +103,62 @@ class UMnetequip(UMnetdbBase):
         sql = self._build_select(select, table, where=where)
         return self._execute(sql)
 
-    def get_device(self, name_or_ip:str, location_info:bool=False):
-
+    def get_device(self, name_or_ip: str, location_info: bool = False):
         if is_ip_address(name_or_ip):
             where = [f"ip_address='{name_or_ip}'"]
         else:
-            name_or_ip = name_or_ip.replace(".umnet.umich.edu","")
+            name_or_ip = name_or_ip.replace(".umnet.umich.edu", "")
             where = [f"dns_name='{name_or_ip}'"]
 
-        select = [ 'dns_name',
-                   'ip_address',
-                   'model_no_ as model',
-                   'types as device_type', 
-                   'rancid',
-                   'off_line',          
-                 ]
+        select = [
+            "dns_name",
+            "ip_address",
+            "model_no_ as model",
+            "types as device_type",
+            "rancid",
+            "off_line",
+        ]
         if location_info:
-            select.extend([
-                    'bldg as building_name',
-                    'address as building_address',
-                    'room as room_no',
-                    'floor as floor',    
-                    'bldg_code__ as building_no',     
-            ])
-        table = 'ARADMIN1.UMNET_EQUIPMENT eq'
+            select.extend(
+                [
+                    "bldg as building_name",
+                    "address as building_address",
+                    "room as room_no",
+                    "floor as floor",
+                    "bldg_code__ as building_no",
+                ]
+            )
+        table = "ARADMIN1.UMNET_EQUIPMENT eq"
 
         sql = self._build_select(select, table, where=where)
         return self._execute(sql)
 
     def get_all_devices(self):
-        select = [  "bldg_code__ as bldg_code",
-                    "bldg",
-                    "room",
-                    "ip_address",
-                    "dns_name",
-                    "category",
-                    "types",
-                    "manufacturer",
-                    "serial_number",
-                    "billing_code_ as billing_code",
-                    "warehouse_item__ as warehouse_item",
-                    "st.descr as status",
-                    "sla_network",
-                    "address",
-                    "floor",
-                    "model_no_ as model_no",
-                    "customer_name",
-                    "mat_l_item_description",
-                    "rancid",
-                    "off_line",
-                 ]
-        table = 'ARADMIN1.UMNET_EQUIPMENT eq'
+        select = [
+            "bldg_code__ as bldg_code",
+            "bldg",
+            "room",
+            "ip_address",
+            "dns_name",
+            "category",
+            "types",
+            "manufacturer",
+            "serial_number",
+            "billing_code_ as billing_code",
+            "warehouse_item__ as warehouse_item",
+            "st.descr as status",
+            "sla_network",
+            "address",
+            "floor",
+            "model_no_ as model_no",
+            "customer_name",
+            "mat_l_item_description",
+            "rancid",
+            "off_line",
+        ]
+        table = "ARADMIN1.UMNET_EQUIPMENT eq"
         joins = ["join ARADMIN1.UMNET_EQUIPMENT_STATUS st on st.idnum=eq.status"]
         where = ["eq.status != 3"]
 
-        sql = self._build_select(select, table,where=where, joins=joins)
-        return self._execute(sql)
+        sql = self._build_select(select, table, where=where, joins=joins)
+        return self._execute(sql)

umnetdb_utils/umnetinfo.py

@@ -1,14 +1,14 @@
-
-
 import ipaddress
 import re
 from .base import UMnetdbBase
 from .utils import is_ip_address, is_ip_network, is_mac_address
 
+
 class UMnetinfo(UMnetdbBase):
     """
     Wraps helpful netinfo db queries into python
     """
+
     URL = "oracle+oracledb://{NETINFO_USERNAME}:{NETINFO_PASSWORD}@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=kannada.web.itd.umich.edu)(PORT=1521))(CONNECT_DATA=(SID=KANNADA)))"
 
     def get_network_by_name(self, netname, active_only=False):
@@ -365,7 +365,6 @@ class UMnetinfo(UMnetdbBase):
 
         # dns names in the device table are fqdn and end in a dot (eg 'dl-arbl-1.umnet.umich.edu.')
         else:
-
             name_or_ip = name_or_ip.lower()
             if "." not in name_or_ip:
                 name_or_ip += ".umnet.umich.edu"
@@ -417,7 +416,6 @@ class UMnetinfo(UMnetdbBase):
         # UMNET.ARPHIST stores MACs as strings without separators .:-, ie
         # 0010.abcd.1010 => '0010abcd1010'
         if is_mac_address(query):
-
             arphist_mac = re.sub(r"[\.\:\-]", "", query)
             where.append(f"arp.mac_addr = '{arphist_mac}'")
 
@@ -456,7 +454,6 @@ class UMnetinfo(UMnetdbBase):
         # isn't throwing anyone :-/
         processed_results = []
         for r in results:
-
             processed = {
                 "ip": ipaddress.ip_address(r["address32bit"]),
                 "mac": f"{r['mac_addr'][0:4]}.{r['mac_addr'][4:8]}.{r['mac_addr'][8:12]}",
@@ -486,4 +483,4 @@ class UMnetinfo(UMnetdbBase):
         sql = self._build_select(select, table, where=where, order_by="1,2")
         results = self._execute(sql)
 
-        return results
+        return results

umnetdb_utils/utils.py

@@ -1,5 +1,7 @@
 import ipaddress
 import re
+
+
 def is_ip_address(input_str, version=None):
     try:
         ip = ipaddress.ip_address(input_str)
@@ -11,8 +13,8 @@ def is_ip_address(input_str, version=None):
 
     return True
 
+
 def is_ip_network(input_str, version=None):
- 
     # First check that this is a valid IP or network
     try:
         net = ipaddress.ip_network(input_str)
@@ -21,19 +23,20 @@ def is_ip_network(input_str, version=None):
 
     if version and version != net.version:
         return False
-    
+
     return True
 
+
 def is_mac_address(input_str):
-    '''
+    """
     Validates the input string as a mac address. Valid formats are
     XX:XX:XX:XX:XX:XX, XX-XX-XX-XX-XX-XX, XXXX.XXXX.XXXX
     where 'X' is a hexadecimal digit (upper or lowercase).
-    '''
+    """
     mac = input_str.lower()
-    if re.match(r'[0-9a-f]{2}([-:])[0-9a-f]{2}(\1[0-9a-f]{2}){4}$', mac):
+    if re.match(r"[0-9a-f]{2}([-:])[0-9a-f]{2}(\1[0-9a-f]{2}){4}$", mac):
         return True
-    if re.match(r'[0-9a-f]{4}\.[0-9a-f]{4}\.[0-9a-f]{4}$', mac):
+    if re.match(r"[0-9a-f]{4}\.[0-9a-f]{4}\.[0-9a-f]{4}$", mac):
         return True
 
     return False

{umnetdb_utils-0.1.4.dist-info → umnetdb_utils-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umnetdb-utils
-Version: 0.1.4
+Version: 0.1.5
 Summary: Helper classes for querying UMnet databases
 License: MIT
 Author: Amy Liebowitz

umnetdb_utils-0.1.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+umnetdb_utils/__init__.py,sha256=YrT7drJ2MlU287z4--8EQI3fKLQZBlVxaCacU1yoDtg,132
+umnetdb_utils/base.py,sha256=LWVhrbShhuYekXZxwvhhVUkH6DHd_wnJ2QZ_zw3fKqM,6139
+umnetdb_utils/umnetdb.py,sha256=jHifl5eJXzye28mjLnfn7A7zwN2Y4YuKgrFvjV5MQBI,4953
+umnetdb_utils/umnetdisco.py,sha256=D9MiF_QrYznYL_ozLUmD1ASzkGDs1jqZ_XksNV7wW3o,8018
+umnetdb_utils/umnetequip.py,sha256=Nnh_YCcqGpYRp2KsS8qbAGJ9AgTeYB4umeYeP9_B-6A,5440
+umnetdb_utils/umnetinfo.py,sha256=vqFvLbIu7Wu650RTqzaELpbKhq6y91fgBXM5Q_elRl4,18443
+umnetdb_utils/utils.py,sha256=VLxfBKq1iOQVxTuySvxV4goE_jtX4jCshjf9a5ky1vI,989
+umnetdb_utils-0.1.5.dist-info/METADATA,sha256=fPpx67_VnM0Xp6JGk13mRrxOte8wPAkau0O0PtM9vW0,1555
+umnetdb_utils-0.1.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+umnetdb_utils-0.1.5.dist-info/RECORD,,

umnetdb_utils-0.1.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-umnetdb_utils/__init__.py,sha256=QJaytbr4ccKESiwaKjpf1b4b8s2cHNfCDdnCOs1tmoI,131
-umnetdb_utils/base.py,sha256=aC5oKSB5Ox9QtylmHV2uvEUVUx4CRLZTgH6HpQJ6DZo,6064
-umnetdb_utils/umnetdb.py,sha256=IxqpAcPZn71HVV_oL3ryvbKS7cupUsyM6rJSGk6NLaU,4554
-umnetdb_utils/umnetdisco.py,sha256=Z2XwT79jKO_avd3w_z99DDEdAikrfKxYm1JYHRWqvG4,7841
-umnetdb_utils/umnetequip.py,sha256=jOW5kvk0FXtdHv8PA4rYT_PWfLdMiq83Mjwmy-c1DN8,5701
-umnetdb_utils/umnetinfo.py,sha256=MH1YDW4OWtHD46qfYb5Pv40vPSbL0GrMNW5gAhdlihE,18445
-umnetdb_utils/utils.py,sha256=wU6QMYfofj7trX3QeqXty0btbGdhP_RUaSqA7QTflFM,991
-umnetdb_utils-0.1.4.dist-info/METADATA,sha256=JI2hwHkX3B8y-GLwS0yywAiFszcqUlkiWUyga0A2KaY,1555
-umnetdb_utils-0.1.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-umnetdb_utils-0.1.4.dist-info/RECORD,,