How to use the ciscoconfparse.local_py.ipaddr.NetmaskValueError function in ciscoconfparse

else:
            # Assume input argument to be string or any object representation
            # which converts into a formatted IP prefix string.
            addr = str(address).split('/')

            if len(addr) > 2:
                raise AddressValueError(address)

            self._ip = self._ip_int_from_string(addr[0])
            self.ip = IPv4Address(self._ip)

            if len(addr) == 2:
                try:
                    # Check for a netmask in prefix length form.
                    self._prefixlen = self._prefix_from_prefix_string(addr[1])
                except NetmaskValueError:
                    # Check for a netmask or hostmask in dotted-quad form.
                    # This may raise NetmaskValueError.
                    self._prefixlen = self._prefix_from_ip_string(addr[1])
            else:
                self._prefixlen = self._max_prefixlen

        self.netmask = IPv4Address(self._ip_int_from_prefix(self._prefixlen))

        if strict:
            if self.ip != self.network:
                raise ValueError('%s has host bits set' % self.ip)
        if self._prefixlen == (self._max_prefixlen - 1):
            self.iterhosts = self.__iter__

"""Validate and return a prefix length integer.

        Args:
            prefixlen: An integer containing the prefix length.

        Returns:
            The input, possibly converted from long to int.

        Raises:
            NetmaskValueError: If the input is not an integer, or out of range.
        """
        if not isinstance(prefixlen, (int, long)):
            raise NetmaskValueError('%r is not an integer' % prefixlen)
        prefixlen = int(prefixlen)
        if not (0 <= prefixlen <= self._max_prefixlen):
            raise NetmaskValueError('%d is not a valid prefix length' %
                                    prefixlen)
        return prefixlen

Raises:
            NetmaskValueError: If the input is not a valid netmask.

        """
        prefixlen = self._max_prefixlen
        while prefixlen:
            if ip_int & 1:
                break
            ip_int >>= 1
            prefixlen -= 1

        if ip_int == (1 << prefixlen) - 1:
            return prefixlen
        else:
            raise NetmaskValueError('Bit pattern does not match /1*0*/')

Args:
            ip_str: A netmask or hostmask, formatted as an IP address.

        Returns:
            The prefix length as an integer.

        Raises:
            NetmaskValueError: If the input is not a netmask or hostmask.

        """
        # Parse the netmask/hostmask like an IP address.
        try:
            ip_int = self._ip_int_from_string(ip_str)
        except AddressValueError:
            raise NetmaskValueError('%s is not a valid netmask' % ip_str)

        # Try matching a netmask (this would be /1*0*/ as a bitwise regexp).
        # Note that the two ambiguous cases (all-ones and all-zeroes) are
        # treated as netmasks.
        try:
            return self._prefix_from_ip_int(ip_int)
        except NetmaskValueError:
            pass

        # Invert the bits, and try matching a /0+1+/ hostmask instead.
        ip_int ^= self._ALL_ONES
        try:
            return self._prefix_from_ip_int(ip_int)
        except NetmaskValueError:
            raise NetmaskValueError('%s is not a valid netmask' % ip_str)