FM / lib

/usr/lib/python3/dist-packages/landscape/lib/

/usr/lib/python3/dist-packages/landscape/lib

Name	Size	Mode	Actions
apt/	-	0755	rm
__pycache__/	-	0755	rm
amp.py	21745	0644	edit dl rm
backoff.py	1683	0644	edit dl rm
base64.py	196	0644	edit dl rm
bootstrap.py	1416	0644	edit dl rm
bpickle.py	6471	0644	edit dl rm
cli.py	440	0644	edit dl rm
cloud.py	1715	0644	edit dl rm
compat.py	616	0644	edit dl rm
config.py	12484	0644	edit dl rm
disk.py	5027	0644	edit dl rm
encoding.py	545	0644	edit dl rm
fd.py	751	0644	edit dl rm
fetch.py	6647	0644	edit dl rm
format.py	959	0644	edit dl rm
fs.py	3889	0644	edit dl rm
gpg.py	1796	0644	edit dl rm
hashlib.py	264	0644	edit dl rm
jiffies.py	1621	0644	edit dl rm
juju.py	860	0644	edit dl rm
lock.py	705	0644	edit dl rm
log.py	484	0644	edit dl rm
logging.py	2528	0644	edit dl rm
message.py	2638	0644	edit dl rm
monitor.py	6281	0644	edit dl rm
network.py	9821	0644	edit dl rm
os_release.py	1324	0644	edit dl rm
persist.py	20995	0644	edit dl rm
plugin.py	1787	0644	edit dl rm
process.py	6603	0644	edit dl rm
reactor.py	8812	0644	edit dl rm
schema.py	6457	0644	edit dl rm
scriptcontent.py	522	0644	edit dl rm
sequenceranges.py	5724	0644	edit dl rm
store.py	1408	0644	edit dl rm
sysstats.py	7920	0644	edit dl rm
tag.py	506	0644	edit dl rm
testing.py	24662	0644	edit dl rm
timestamp.py	233	0644	edit dl rm
twisted_util.py	4476	0644	edit dl rm
user.py	1476	0644	edit dl rm
versioning.py	1265	0644	edit dl rm
vm_info.py	3172	0644	edit dl rm
warning.py	394	0644	edit dl rm
__init__.py	198	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/landscape/lib/sequenceranges.py (5724B)

from twisted.python.compat import xrange

class SequenceError(Exception):
    """Raised when the sequence isn't proper for translation to ranges."""

class SequenceRanges(object):
    """High level interface to ranges.

A ranges list represent a sequence of ordered and non-repeating
    elements into a more compact format, by representing 3 or more
    consecutive entries by a range.

This means that a sequence such as

[1, 2, 4, 5, 6, 8, 10, 11, 12, 14]

becomes

[1, 2, (4, 6), 8, (10, 12), 14]
    """

def __init__(self):
        self._ranges = []

@classmethod
    def from_sequence(cls, sequence):
        obj = cls()
        obj._ranges[:] = sequence_to_ranges(sequence)
        return obj

@classmethod
    def from_ranges(cls, ranges):
        obj = cls()
        obj._ranges[:] = ranges
        return obj

def to_sequence(self):
        return list(ranges_to_sequence(self._ranges))

def to_ranges(self):
        return list(self._ranges)

def __iter__(self):
        return ranges_to_sequence(self._ranges)

def __contains__(self, item):
        index = find_ranges_index(self._ranges, item)
        if index < len(self._ranges):
            test = self._ranges[index]
            if isinstance(test, tuple):
                return (test[0] <= item <= test[1])
            return (test == item)
        return False

def add(self, item):
        add_to_ranges(self._ranges, item)

def remove(self, item):
        remove_from_ranges(self._ranges, item)

def sequence_to_ranges(sequence):
    """Iterate over range items that compose the given sequence."""

iterator = iter(sequence)
    try:
        range_start = range_stop = next(iterator)
    except StopIteration:
        return
    while range_start is not None:
        try:
            item = next(iterator)
        except StopIteration:
            item = None
        if item == range_stop + 1:
            range_stop += 1
        else:
            if item is not None and item <= range_stop:
                if item < range_stop:
                    raise SequenceError("Sequence is unordered (%r < %r)" %
                                        (item, range_stop))
                else:
                    raise SequenceError("Found duplicated item (%r)" % (item,))
            if range_stop == range_start:
                yield range_start
            elif range_stop == range_start + 1:
                yield range_start
                yield range_stop
            else:
                yield (range_start, range_stop)
            range_start = range_stop = item

def ranges_to_sequence(ranges):
    """Iterate over individual items represented in a ranges list."""
    for item in ranges:
        if isinstance(item, tuple):
            start, end = item
            if start > end:
                raise ValueError("Range error %d > %d", start, end)
            for item in xrange(start, end + 1):
                yield item
        else:
            yield item

def find_ranges_index(ranges, item):
    """Find the index where an entry *may* be."""
    lo = 0
    hi = len(ranges)
    while lo < hi:
        mid = (lo + hi) // 2
        test = ranges[mid]
        try:
            test = test[1]
        except TypeError:
            pass
        if item > test:
            lo = mid + 1
        else:
            hi = mid
    return lo

def add_to_ranges(ranges, item):
    """Insert item in ranges, reorganizing as needed."""

index_start = index_stop = index = find_ranges_index(ranges, item)
    range_start = range_stop = item

ranges_len = len(ranges)

# Look for duplicates.
    if index < ranges_len:
        test = ranges[index]
        if isinstance(test, tuple):
            if test[0] <= item <= test[1]:
                return
        elif test == item:
            return

# Merge to the left side.
    while index_start > 0:
        test = ranges[index_start - 1]
        if isinstance(test, tuple):
            if test[1] != range_start - 1:
                break
            range_start = test[0]
        else:
            if test != range_start - 1:
                break
            range_start -= 1
        index_start -= 1

# Merge to the right side.
    while index_stop < ranges_len:
        test = ranges[index_stop]
        if isinstance(test, tuple):
            if test[0] != range_stop + 1:
                break
            range_stop = test[1]
        else:
            if test != range_stop + 1:
                break
            range_stop += 1
        index_stop += 1

if range_stop - range_start < 2:
        ranges.insert(index, item)
    else:
        ranges[index_start:index_stop] = ((range_start, range_stop),)

def remove_from_ranges(ranges, item):
    """Remove item from ranges, reorganizing as needed."""

index = find_ranges_index(ranges, item)
    ranges_len = len(ranges)
    if index < ranges_len:
        test = ranges[index]
        if isinstance(test, tuple):
            range_start, range_stop = test
            if item >= range_start:
                # Handle right side of the range (and replace original item).
                if range_stop < item + 3:
                    ranges[index:index + 1] = range(item + 1, range_stop + 1)
                else:
                    ranges[index:index + 1] = ((item + 1, range_stop),)

# Handle left side of the range.
                if range_start > item - 3:
                    if range_start != item:
                        ranges[index:index] = range(range_start, item)
                else:
                    ranges[index:index] = ((range_start, item - 1),)
        elif item == test:
            del ranges[index]

cmd: