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

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