<h2>Editing File: /lib/python3.6/site-packages/netaddr/strategy/__init__.py</h2><form method='post'><textarea name='content' class='file-edit'>#-----------------------------------------------------------------------------
#   Copyright (c) 2008 by David P. D. Moss. All rights reserved.
#
#   Released under the BSD license. See the LICENSE file for details.
#-----------------------------------------------------------------------------
&quot;&quot;&quot;
Shared logic for various address types.
&quot;&quot;&quot;
import re as _re

from netaddr.compat import _range, _is_str


def bytes_to_bits():
    &quot;&quot;&quot;
    :return: A 256 element list containing 8-bit binary digit strings. The
        list index value is equivalent to its bit string value.
    &quot;&quot;&quot;
    lookup = []
    bits_per_byte = _range(7, -1, -1)
    for num in range(256):
        bits = 8 * [None]
        for i in bits_per_byte:
            bits[i] = '01'[num &amp; 1]
            num &gt;&gt;= 1
        lookup.append(''.join(bits))
    return lookup

#: A lookup table of 8-bit integer values to their binary digit bit strings.
BYTES_TO_BITS = bytes_to_bits()


def valid_words(words, word_size, num_words):
    &quot;&quot;&quot;
    :param words: A sequence of unsigned integer word values.

    :param word_size: Width (in bits) of each unsigned integer word value.

    :param num_words: Number of unsigned integer words expected.

    :return: ``True`` if word sequence is valid for this address type,
        ``False`` otherwise.
    &quot;&quot;&quot;
    if not hasattr(words, '__iter__'):
        return False

    if len(words) != num_words:
        return False

    max_word = 2 ** word_size - 1

    for i in words:
        if not 0 &lt;= i &lt;= max_word:
            return False

    return True


def int_to_words(int_val, word_size, num_words):
    &quot;&quot;&quot;
    :param int_val: Unsigned integer to be divided into words of equal size.

    :param word_size: Width (in bits) of each unsigned integer word value.

    :param num_words: Number of unsigned integer words expected.

    :return: A tuple contain unsigned integer word values split according
        to provided arguments.
    &quot;&quot;&quot;
    max_int = 2 ** (num_words * word_size) - 1

    if not 0 &lt;= int_val &lt;= max_int:
        raise IndexError('integer out of bounds: %r!' % hex(int_val))

    max_word = 2 ** word_size - 1

    words = []
    for _ in range(num_words):
        word = int_val &amp; max_word
        words.append(int(word))
        int_val &gt;&gt;= word_size

    return tuple(reversed(words))


def words_to_int(words, word_size, num_words):
    &quot;&quot;&quot;
    :param words: A sequence of unsigned integer word values.

    :param word_size: Width (in bits) of each unsigned integer word value.

    :param num_words: Number of unsigned integer words expected.

    :return: An unsigned integer that is equivalent to value represented
        by word sequence.
    &quot;&quot;&quot;
    if not valid_words(words, word_size, num_words):
        raise ValueError('invalid integer word sequence: %r!' % words)

    int_val = 0
    for i, num in enumerate(reversed(words)):
        word = num
        word = word &lt;&lt; word_size * i
        int_val = int_val | word

    return int_val


def valid_bits(bits, width, word_sep=''):
    &quot;&quot;&quot;
    :param bits: A network address in a delimited binary string format.

    :param width: Maximum width (in bits) of a network address (excluding
        delimiters).

    :param word_sep: (optional) character or string used to delimit word
        groups (default: '', no separator).

    :return: ``True`` if network address is valid, ``False`` otherwise.
    &quot;&quot;&quot;
    if not _is_str(bits):
        return False

    if word_sep != '':
        bits = bits.replace(word_sep, '')

    if len(bits) != width:
        return False

    max_int = 2 ** width - 1

    try:
        if 0 &lt;= int(bits, 2) &lt;= max_int:
            return True
    except ValueError:
        pass

    return False


def bits_to_int(bits, width, word_sep=''):
    &quot;&quot;&quot;
    :param bits: A network address in a delimited binary string format.

    :param width: Maximum width (in bits) of a network address (excluding
        delimiters).

    :param word_sep: (optional) character or string used to delimit word
        groups (default: '', no separator).

    :return: An unsigned integer that is equivalent to value represented
        by network address in readable binary form.
    &quot;&quot;&quot;
    if not valid_bits(bits, width, word_sep):
        raise ValueError('invalid readable binary string: %r!' % bits)

    if word_sep != '':
        bits = bits.replace(word_sep, '')

    return int(bits, 2)


def int_to_bits(int_val, word_size, num_words, word_sep=''):
    &quot;&quot;&quot;
    :param int_val: An unsigned integer.

    :param word_size: Width (in bits) of each unsigned integer word value.

    :param num_words: Number of unsigned integer words expected.

    :param word_sep: (optional) character or string used to delimit word
        groups (default: '', no separator).

    :return: A network address in a delimited binary string format that is
        equivalent in value to unsigned integer.
    &quot;&quot;&quot;
    bit_words = []

    for word in int_to_words(int_val, word_size, num_words):
        bits = []
        while word:
            bits.append(BYTES_TO_BITS[word &amp; 255])
            word &gt;&gt;= 8
        bits.reverse()
        bit_str = ''.join(bits) or '0' * word_size
        bits = ('0' * word_size + bit_str)[-word_size:]
        bit_words.append(bits)

    if word_sep is not '':
        #   Check custom separator.
        if not _is_str(word_sep):
            raise ValueError('word separator is not a string: %r!' % word_sep)

    return word_sep.join(bit_words)


def valid_bin(bin_val, width):
    &quot;&quot;&quot;
    :param bin_val: A network address in Python's binary representation format
        ('0bxxx').

    :param width: Maximum width (in bits) of a network address (excluding
        delimiters).

    :return: ``True`` if network address is valid, ``False`` otherwise.
    &quot;&quot;&quot;
    if not _is_str(bin_val):
        return False

    if not bin_val.startswith('0b'):
        return False

    bin_val = bin_val.replace('0b', '')

    if len(bin_val) &gt; width:
        return False

    max_int = 2 ** width - 1

    try:
        if 0 &lt;= int(bin_val, 2) &lt;= max_int:
            return True
    except ValueError:
        pass

    return False


def int_to_bin(int_val, width):
    &quot;&quot;&quot;
    :param int_val: An unsigned integer.

    :param width: Maximum allowed width (in bits) of a unsigned integer.

    :return: Equivalent string value in Python's binary representation format
        ('0bxxx').
    &quot;&quot;&quot;
    bin_tokens = []

    try:
        #   Python 2.6.x and upwards.
        bin_val = bin(int_val)
    except NameError:
        #   Python 2.4.x and 2.5.x
        i = int_val
        while i &gt; 0:
            word = i &amp; 0xff
            bin_tokens.append(BYTES_TO_BITS[word])
            i &gt;&gt;= 8

        bin_tokens.reverse()
        bin_val = '0b' + _re.sub(r'^[0]+([01]+)$', r'\1', ''.join(bin_tokens))

    if len(bin_val[2:]) &gt; width:
        raise IndexError('binary string out of bounds: %s!' % bin_val)

    return bin_val


def bin_to_int(bin_val, width):
    &quot;&quot;&quot;
    :param bin_val: A string containing an unsigned integer in Python's binary
        representation format ('0bxxx').

    :param width: Maximum allowed width (in bits) of a unsigned integer.

    :return: An unsigned integer that is equivalent to value represented
        by Python binary string format.
    &quot;&quot;&quot;
    if not valid_bin(bin_val, width):
        raise ValueError('not a valid Python binary string: %r!' % bin_val)

    return int(bin_val.replace('0b', ''), 2)
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fpython3.6%2Fsite-packages%2Fnetaddr%2Fstrategy'>Back to Directory</a>