cisco-config-parser 2.2.7__tar.gz → 2.2.9__tar.gz

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cisco_config_parser
-Version: 2.2.7
+Version: 2.2.9
 Summary: This library is used for Network Automation involving Cisco Routers and Switch. It will parse Cisco IOS, IOS-XE, IOS-XR, and NXOS configuration file into objects and/or json format
 Home-page: https://github.com/arezazadeh/cisco_config_parser
 Author: Ahmad Rezazadeh

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/cisco_config_parser/__init__.py

@@ -6,7 +6,7 @@ _ALL_ = [
     "ConfigParserOld",
 ]
 
-__version__ = "2.2.7"
+__version__ = "2.2.9"
 __author__ = "Ahmad Rezazadeh"
 __email__ = "ahmad@klevernet.io"
 __url__ = "klevernet.ai"

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/cisco_config_parser/layer3_interface/l3_interface_parser.py

@@ -41,25 +41,27 @@ class L3InterfaceParser:
 
         for l3_interface in l3_interfaces:
 
+            l3_interface_stripped = "\n".join([line.strip() for line in l3_interface.split("\n") if line.strip()])
             # create an instance of the L3Interface class
             l3_intf_cls = L3Interface()
 
             # split the l3_interface section into lines
             # remove the first line which is the interface name
             # and store the rest of the lines in the children attribute of the l3_intf_cls object
-            l3_intf_split_line = SPLIT_ON_LINE.split(l3_interface)
+            l3_intf_split_line = SPLIT_ON_LINE.split(l3_interface_stripped)
             l3_intf_cls.children = [
                 line.strip() for line in l3_intf_split_line
                 if line and not line.startswith("interface")
             ]
 
             # search for the regex in the l3_interface section
-            interface_regex = INTERFACE_MULTILINE_REGEX.search(l3_interface)
-            description_regex = DESCRIPTION_REGEX.search(l3_interface)
-            ip_address_regex = IP_ADDRESS_REGEX.search(l3_interface)
-            vrf_regex = VRF_REGEX.search(l3_interface)
-            helper_address_regex = HELPER_ADDRESS_REGEX.search(l3_interface)
-            sec_ip_address_regex = SECONDARY_IP_ADDRESS_REGEX.search(l3_interface)
+            interface_regex = INTERFACE_MULTILINE_REGEX.search(l3_interface_stripped)
+            description_regex = DESCRIPTION_REGEX.search(l3_interface_stripped)
+            ip_address_regex = IP_ADDRESS_REGEX.search(l3_interface_stripped)
+            vrf_regex = VRF_REGEX.search(l3_interface_stripped)
+            helper_address_regex = HELPER_ADDRESS_REGEX.search(l3_interface_stripped)
+            sec_ip_address_regex = SECONDARY_IP_ADDRESS_REGEX.search(l3_interface_stripped)
+
 
 
             # if the regex is found, parse the line and store the value in the l3_intf_cls object
@@ -76,13 +78,14 @@ class L3InterfaceParser:
             if sec_ip_address_regex:
                 # set the primary flag to False to indicate that the ip address is a secondary ip address
                 ip_address_kwargs["primary"] = False
+                ip_address_kwargs["ip_address_line_regex"] = sec_ip_address_regex
                 l3_intf_cls = _L3SectionParser._parse_ip_address_line(**ip_address_kwargs)
 
             if vrf_regex:
                 l3_intf_cls = _L3SectionParser._parse_vrf_line(vrf_line_regex=vrf_regex, l3_interface_obj=l3_intf_cls)
 
             if helper_address_regex:
-                l3_intf_cls = _L3SectionParser._parse_helper_address_line(l3_interface_obj=l3_intf_cls, section=l3_interface)
+                l3_intf_cls = _L3SectionParser._parse_helper_address_line(l3_interface_obj=l3_intf_cls, section=l3_interface_stripped)
 
             if interface_regex:
                 l3_intf_cls.name = interface_regex.group(1).strip()

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/cisco_config_parser/layer3_interface/l3_section_parser.py

@@ -19,7 +19,37 @@ class _L3SectionParser:
         return: l3_interface_obj
         """
 
-        def process_ip_address_with_cidr(ip_address_with_cidr, obj):
+
+        def cleanup_ip_address(ip_address_line_regex):
+            ip_address_regex = [ip_group for ip_group in ip_address_line_regex.groups() if ip_group]
+            if not ip_address_regex:
+                return None
+
+            if "/" in ip_address_regex[0]:
+                ip_address_config = ip_address_regex[0].split("/")
+                ip_addr = ip_address_config[0].strip()
+                cidr = ip_address_config[1].strip()
+                subnet_ = ipaddress.IPv4Network(f"{ip_addr}/{cidr}", strict=False)
+                return {
+                    "ip_address": ip_addr.strip(),
+                    "mask": str(subnet_.netmask),
+                    "subnet": str(subnet_).strip()
+                }
+
+            else:
+                ip_address_section = ip_address_regex[0].split()
+                ip_address = ip_address_section[0].strip()
+                mask = ip_address_section[1].strip()
+                subnet = str(ipaddress.IPv4Network(f"{ip_address}/{mask}", strict=False))
+                return {
+                    "ip_address": ip_address.strip(),
+                    "mask": mask.strip(),
+                    "subnet": subnet.strip()
+                }
+
+
+
+        def process_ip_address_with_cidr(ip_address_with_cidr, obj, primary=True):
             """
             Process the ip address with cidr
             :param ip_address_with_cidr: str
@@ -39,25 +69,36 @@ class _L3SectionParser:
         l3_interface_obj = kwargs.get("l3_interface_obj")
         primary = kwargs.get("primary", True)
 
-        ip_address_regex = [ip_group for ip_group in ip_address_line_regex.groups() if ip_group]
+        ip_info = cleanup_ip_address(ip_address_line_regex)
+        # ip_address_regex = [ip_group for ip_group in ip_address_line_regex.groups() if ip_group]
 
+        # print(ip_address_regex)
         # Check if the ip address has a CIDR - 10.1.1.1/24
-        if "/" in ip_address_regex[0]:
-            l3_interface_obj = process_ip_address_with_cidr(ip_address_regex[0], l3_interface_obj)
-            return l3_interface_obj
-
-        ip_address_section = ip_address_regex[0].split()
-        ip_address = ip_address_section[0].strip()
-        mask = ip_address_section[1].strip()
-        subnet = str(ipaddress.IPv4Network(f"{ip_address}/{mask}", strict=False))
+        # if "/" in ip_address_regex[0]:
+        #
+        #     l3_interface_obj = process_ip_address_with_cidr(ip_address_regex[0], l3_interface_obj)
+        #     return l3_interface_obj
+
+        # ip_address_section = ip_address_regex[0].split()
+        # ip_address = ip_address_section[0].strip()
+        # mask = ip_address_section[1].strip()
+        # subnet = str(ipaddress.IPv4Network(f"{ip_address}/{mask}", strict=False))
         if primary:
-            l3_interface_obj.ip_address = ip_address.strip()
-            l3_interface_obj.mask = mask.strip()
-            l3_interface_obj.subnet = subnet.strip()
+            l3_interface_obj.ip_address = ip_info["ip_address"].strip()
+            l3_interface_obj.mask = ip_info["mask"].strip()
+            l3_interface_obj.subnet = ip_info["subnet"].strip()
+
+            # l3_interface_obj.ip_address = ip_address.strip()
+            # l3_interface_obj.mask = mask.strip()
+            # l3_interface_obj.subnet = subnet.strip()
         else:
-            l3_interface_obj.sec_ip_address = ip_address.strip()
-            l3_interface_obj.sec_mask = mask.strip()
-            l3_interface_obj.sec_subnet = subnet.strip()
+            l3_interface_obj.sec_ip_address = ip_info["ip_address"].strip()
+            l3_interface_obj.sec_mask = ip_info["mask"].strip()
+            l3_interface_obj.sec_subnet = ip_info["subnet"].strip()
+
+            # l3_interface_obj.sec_ip_address = ip_address.strip()
+            # l3_interface_obj.sec_mask = mask.strip()
+            # l3_interface_obj.sec_subnet = subnet.strip()
 
         return l3_interface_obj
 
@@ -73,7 +114,9 @@ class _L3SectionParser:
         vrf_line_regex = kwargs.get("vrf_line_regex")
         l3_interface_obj = kwargs.get("l3_interface_obj")
         vrf = vrf_line_regex.groups()
+
         vrf = [vrf_group for vrf_group in vrf if vrf_group][0]
+
         l3_interface_obj.vrf = vrf.strip()
         return l3_interface_obj
 

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/cisco_config_parser/parser_regex/ios_regex.py

@@ -28,10 +28,11 @@ INTERFACE_REGEX = re.compile(r"interface\s(.*)", flags=re.MULTILINE)
 # L3 Interface
 DESCRIPTION_REGEX = re.compile(r"description\s(.*)", flags=re.MULTILINE)
 IP_ADDRESS_REGEX = re.compile(r"ip\saddress\s(\d+\.\d+\.\d+\.\d+\s\d+\.\d+\.\d+\.\d+)|ip\saddress\s(\d+\.\d+\.\d+\.\d+/\d+)|ipv4\saddress\s(\d+\.\d+\.\d+\.\d+\s\d+\.\d+\.\d+\.\d+)|ipv4\saddress\s(\d+\.\d+\.\d+\.\d+/\d+)")
-IP_ADDRESS_CIDR_REGEX = re.compile(r"ip\saddress\s(\d+\.\d+\.\d+\.\d+/\d+)")
-HELPER_ADDRESS_REGEX = re.compile(r"ip\shelper-address\s(.*)")
-SECONDARY_IP_ADDRESS_REGEX = re.compile(r"ip\saddress\s(.*)secondary")
-VRF_REGEX = re.compile(r"ip\svrf\sforwarding\s(.*)|vrf\smember\s(.*)|vrf\s(.*)")
+# IP_ADDRESS_REGEX = re.compile(r"ipv?4?\saddress\s(\d+\.\d+\.\d+\.\d+)(\s\d+\.\d+\.\d+\.\d+|/\d+)?", flags=re.MULTILINE)
+IP_ADDRESS_CIDR_REGEX = re.compile(r"ip\saddress\s(\d+\.\d+\.\d+\.\d+/\d+)", flags=re.MULTILINE)
+HELPER_ADDRESS_REGEX = re.compile(r"ip\shelper-address\s(.*)", flags=re.MULTILINE)
+SECONDARY_IP_ADDRESS_REGEX = re.compile(r"^ip\saddress\s(.*)\ssecondary", flags=re.MULTILINE)
+VRF_REGEX = re.compile(r"^ip\svrf\sforwarding\s(.*)|^vrf\smember\s(.*)|^vrf\sforwarding\s(.*)|^vrf\s(\S+)$", flags=re.MULTILINE)
 
 
 

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/cisco_config_parser/setup.py

@@ -3,6 +3,6 @@ from setuptools import setup, find_packages
 
 setup(
     name='cisco_config_parser',
-    version='2.2.7',
+    version='2.2.9',
     packages=find_packages(),
 )

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/cisco_config_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cisco_config_parser
-Version: 2.2.7
+Version: 2.2.9
 Summary: This library is used for Network Automation involving Cisco Routers and Switch. It will parse Cisco IOS, IOS-XE, IOS-XR, and NXOS configuration file into objects and/or json format
 Home-page: https://github.com/arezazadeh/cisco_config_parser
 Author: Ahmad Rezazadeh

{cisco_config_parser-2.2.7 → cisco_config_parser-2.2.9}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 HERE = pathlib.Path(__file__).parent
 
-VERSION = '2.2.7'
+VERSION = '2.2.9'
 PACKAGE_NAME = 'cisco_config_parser'
 AUTHOR = 'Ahmad Rezazadeh'
 AUTHOR_EMAIL = 'ahmad@klevernet.io'