okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/utils/heaps.py

@@ -1,338 +0,0 @@
-"""
-Min-heaps.
-"""
-
-from heapq import heappop, heappush
-from itertools import count
-
-import networkx as nx
-
-__all__ = ["MinHeap", "PairingHeap", "BinaryHeap"]
-
-
-class MinHeap:
-    """Base class for min-heaps.
-
-    A MinHeap stores a collection of key-value pairs ordered by their values.
-    It supports querying the minimum pair, inserting a new pair, decreasing the
-    value in an existing pair and deleting the minimum pair.
-    """
-
-    class _Item:
-        """Used by subclassess to represent a key-value pair."""
-
-        __slots__ = ("key", "value")
-
-        def __init__(self, key, value):
-            self.key = key
-            self.value = value
-
-        def __repr__(self):
-            return repr((self.key, self.value))
-
-    def __init__(self):
-        """Initialize a new min-heap."""
-        self._dict = {}
-
-    def min(self):
-        """Query the minimum key-value pair.
-
-        Returns
-        -------
-        key, value : tuple
-            The key-value pair with the minimum value in the heap.
-
-        Raises
-        ------
-        NetworkXError
-            If the heap is empty.
-        """
-        raise NotImplementedError
-
-    def pop(self):
-        """Delete the minimum pair in the heap.
-
-        Returns
-        -------
-        key, value : tuple
-            The key-value pair with the minimum value in the heap.
-
-        Raises
-        ------
-        NetworkXError
-            If the heap is empty.
-        """
-        raise NotImplementedError
-
-    def get(self, key, default=None):
-        """Returns the value associated with a key.
-
-        Parameters
-        ----------
-        key : hashable object
-            The key to be looked up.
-
-        default : object
-            Default value to return if the key is not present in the heap.
-            Default value: None.
-
-        Returns
-        -------
-        value : object.
-            The value associated with the key.
-        """
-        raise NotImplementedError
-
-    def insert(self, key, value, allow_increase=False):
-        """Insert a new key-value pair or modify the value in an existing
-        pair.
-
-        Parameters
-        ----------
-        key : hashable object
-            The key.
-
-        value : object comparable with existing values.
-            The value.
-
-        allow_increase : bool
-            Whether the value is allowed to increase. If False, attempts to
-            increase an existing value have no effect. Default value: False.
-
-        Returns
-        -------
-        decreased : bool
-            True if a pair is inserted or the existing value is decreased.
-        """
-        raise NotImplementedError
-
-    def __nonzero__(self):
-        """Returns whether the heap if empty."""
-        return bool(self._dict)
-
-    def __bool__(self):
-        """Returns whether the heap if empty."""
-        return bool(self._dict)
-
-    def __len__(self):
-        """Returns the number of key-value pairs in the heap."""
-        return len(self._dict)
-
-    def __contains__(self, key):
-        """Returns whether a key exists in the heap.
-
-        Parameters
-        ----------
-        key : any hashable object.
-            The key to be looked up.
-        """
-        return key in self._dict
-
-
-class PairingHeap(MinHeap):
-    """A pairing heap."""
-
-    class _Node(MinHeap._Item):
-        """A node in a pairing heap.
-
-        A tree in a pairing heap is stored using the left-child, right-sibling
-        representation.
-        """
-
-        __slots__ = ("left", "next", "prev", "parent")
-
-        def __init__(self, key, value):
-            super().__init__(key, value)
-            # The leftmost child.
-            self.left = None
-            # The next sibling.
-            self.next = None
-            # The previous sibling.
-            self.prev = None
-            # The parent.
-            self.parent = None
-
-    def __init__(self):
-        """Initialize a pairing heap."""
-        super().__init__()
-        self._root = None
-
-    def min(self):
-        if self._root is None:
-            raise nx.NetworkXError("heap is empty.")
-        return (self._root.key, self._root.value)
-
-    def pop(self):
-        if self._root is None:
-            raise nx.NetworkXError("heap is empty.")
-        min_node = self._root
-        self._root = self._merge_children(self._root)
-        del self._dict[min_node.key]
-        return (min_node.key, min_node.value)
-
-    def get(self, key, default=None):
-        node = self._dict.get(key)
-        return node.value if node is not None else default
-
-    def insert(self, key, value, allow_increase=False):
-        node = self._dict.get(key)
-        root = self._root
-        if node is not None:
-            if value < node.value:
-                node.value = value
-                if node is not root and value < node.parent.value:
-                    self._cut(node)
-                    self._root = self._link(root, node)
-                return True
-            elif allow_increase and value > node.value:
-                node.value = value
-                child = self._merge_children(node)
-                # Nonstandard step: Link the merged subtree with the root. See
-                # below for the standard step.
-                if child is not None:
-                    self._root = self._link(self._root, child)
-                # Standard step: Perform a decrease followed by a pop as if the
-                # value were the smallest in the heap. Then insert the new
-                # value into the heap.
-                # if node is not root:
-                #     self._cut(node)
-                #     if child is not None:
-                #         root = self._link(root, child)
-                #     self._root = self._link(root, node)
-                # else:
-                #     self._root = (self._link(node, child)
-                #                   if child is not None else node)
-            return False
-        else:
-            # Insert a new key.
-            node = self._Node(key, value)
-            self._dict[key] = node
-            self._root = self._link(root, node) if root is not None else node
-            return True
-
-    def _link(self, root, other):
-        """Link two nodes, making the one with the smaller value the parent of
-        the other.
-        """
-        if other.value < root.value:
-            root, other = other, root
-        next = root.left
-        other.next = next
-        if next is not None:
-            next.prev = other
-        other.prev = None
-        root.left = other
-        other.parent = root
-        return root
-
-    def _merge_children(self, root):
-        """Merge the subtrees of the root using the standard two-pass method.
-        The resulting subtree is detached from the root.
-        """
-        node = root.left
-        root.left = None
-        if node is not None:
-            link = self._link
-            # Pass 1: Merge pairs of consecutive subtrees from left to right.
-            # At the end of the pass, only the prev pointers of the resulting
-            # subtrees have meaningful values. The other pointers will be fixed
-            # in pass 2.
-            prev = None
-            while True:
-                next = node.next
-                if next is None:
-                    node.prev = prev
-                    break
-                next_next = next.next
-                node = link(node, next)
-                node.prev = prev
-                prev = node
-                if next_next is None:
-                    break
-                node = next_next
-            # Pass 2: Successively merge the subtrees produced by pass 1 from
-            # right to left with the rightmost one.
-            prev = node.prev
-            while prev is not None:
-                prev_prev = prev.prev
-                node = link(prev, node)
-                prev = prev_prev
-            # Now node can become the new root. Its has no parent nor siblings.
-            node.prev = None
-            node.next = None
-            node.parent = None
-        return node
-
-    def _cut(self, node):
-        """Cut a node from its parent."""
-        prev = node.prev
-        next = node.next
-        if prev is not None:
-            prev.next = next
-        else:
-            node.parent.left = next
-        node.prev = None
-        if next is not None:
-            next.prev = prev
-            node.next = None
-        node.parent = None
-
-
-class BinaryHeap(MinHeap):
-    """A binary heap."""
-
-    def __init__(self):
-        """Initialize a binary heap."""
-        super().__init__()
-        self._heap = []
-        self._count = count()
-
-    def min(self):
-        dict = self._dict
-        if not dict:
-            raise nx.NetworkXError("heap is empty")
-        heap = self._heap
-        # Repeatedly remove stale key-value pairs until a up-to-date one is
-        # met.
-        while True:
-            value, _, key = heap[0]
-            if key in dict and value == dict[key]:
-                break
-            heappop(heap)
-        return (key, value)
-
-    def pop(self):
-        dict = self._dict
-        if not dict:
-            raise nx.NetworkXError("heap is empty")
-        heap = self._heap
-        # Repeatedly remove stale key-value pairs until a up-to-date one is
-        # met.
-        while True:
-            value, _, key = heap[0]
-            heappop(heap)
-            if key in dict and value == dict[key]:
-                break
-        del dict[key]
-        return (key, value)
-
-    def get(self, key, default=None):
-        return self._dict.get(key, default)
-
-    def insert(self, key, value, allow_increase=False):
-        dict = self._dict
-        if key in dict:
-            old_value = dict[key]
-            if value < old_value or (allow_increase and value > old_value):
-                # Since there is no way to efficiently obtain the location of a
-                # key-value pair in the heap, insert a new pair even if ones
-                # with the same key may already be present. Deem the old ones
-                # as stale and skip them when the minimum pair is queried.
-                dict[key] = value
-                heappush(self._heap, (value, next(self._count), key))
-                return value < old_value
-            return False
-        else:
-            dict[key] = value
-            heappush(self._heap, (value, next(self._count), key))
-            return True

package/runtime/python/okstra_vendor/networkx/utils/mapped_queue.py

@@ -1,297 +0,0 @@
-"""Priority queue class with updatable priorities."""
-
-import heapq
-
-__all__ = ["MappedQueue"]
-
-
-class _HeapElement:
-    """This proxy class separates the heap element from its priority.
-
-    The idea is that using a 2-tuple (priority, element) works
-    for sorting, but not for dict lookup because priorities are
-    often floating point values so round-off can mess up equality.
-
-    So, we need inequalities to look at the priority (for sorting)
-    and equality (and hash) to look at the element to enable
-    updates to the priority.
-
-    Unfortunately, this class can be tricky to work with if you forget that
-    `__lt__` compares the priority while `__eq__` compares the element.
-    In `greedy_modularity_communities()` the following code is
-    used to check that two _HeapElements differ in either element or priority:
-
-        if d_oldmax != row_max or d_oldmax.priority != row_max.priority:
-
-    If the priorities are the same, this implementation uses the element
-    as a tiebreaker. This provides compatibility with older systems that
-    use tuples to combine priority and elements.
-    """
-
-    __slots__ = ["priority", "element", "_hash"]
-
-    def __init__(self, priority, element):
-        self.priority = priority
-        self.element = element
-        self._hash = hash(element)
-
-    def __lt__(self, other):
-        try:
-            other_priority = other.priority
-        except AttributeError:
-            return self.priority < other
-        # assume comparing to another _HeapElement
-        if self.priority == other_priority:
-            try:
-                return self.element < other.element
-            except TypeError as err:
-                raise TypeError(
-                    "Consider using a tuple, with a priority value that can be compared."
-                )
-        return self.priority < other_priority
-
-    def __gt__(self, other):
-        try:
-            other_priority = other.priority
-        except AttributeError:
-            return self.priority > other
-        # assume comparing to another _HeapElement
-        if self.priority == other_priority:
-            try:
-                return self.element > other.element
-            except TypeError as err:
-                raise TypeError(
-                    "Consider using a tuple, with a priority value that can be compared."
-                )
-        return self.priority > other_priority
-
-    def __eq__(self, other):
-        try:
-            return self.element == other.element
-        except AttributeError:
-            return self.element == other
-
-    def __hash__(self):
-        return self._hash
-
-    def __getitem__(self, indx):
-        return self.priority if indx == 0 else self.element[indx - 1]
-
-    def __iter__(self):
-        yield self.priority
-        try:
-            yield from self.element
-        except TypeError:
-            yield self.element
-
-    def __repr__(self):
-        return f"_HeapElement({self.priority}, {self.element})"
-
-
-class MappedQueue:
-    """The MappedQueue class implements a min-heap with removal and update-priority.
-
-    The min heap uses heapq as well as custom written _siftup and _siftdown
-    methods to allow the heap positions to be tracked by an additional dict
-    keyed by element to position. The smallest element can be popped in O(1) time,
-    new elements can be pushed in O(log n) time, and any element can be removed
-    or updated in O(log n) time. The queue cannot contain duplicate elements
-    and an attempt to push an element already in the queue will have no effect.
-
-    MappedQueue complements the heapq package from the python standard
-    library. While MappedQueue is designed for maximum compatibility with
-    heapq, it adds element removal, lookup, and priority update.
-
-    Parameters
-    ----------
-    data : dict or iterable
-
-    Examples
-    --------
-
-    A `MappedQueue` can be created empty, or optionally, given a dictionary
-    of initial elements and priorities.  The methods `push`, `pop`,
-    `remove`, and `update` operate on the queue.
-
-    >>> colors_nm = {"red": 665, "blue": 470, "green": 550}
-    >>> q = MappedQueue(colors_nm)
-    >>> q.remove("red")
-    >>> q.update("green", "violet", 400)
-    >>> q.push("indigo", 425)
-    True
-    >>> [q.pop().element for i in range(len(q.heap))]
-    ['violet', 'indigo', 'blue']
-
-    A `MappedQueue` can also be initialized with a list or other iterable. The priority is assumed
-    to be the sort order of the items in the list.
-
-    >>> q = MappedQueue([916, 50, 4609, 493, 237])
-    >>> q.remove(493)
-    >>> q.update(237, 1117)
-    >>> [q.pop() for i in range(len(q.heap))]
-    [50, 916, 1117, 4609]
-
-    An exception is raised if the elements are not comparable.
-
-    >>> q = MappedQueue([100, "a"])
-    Traceback (most recent call last):
-    ...
-    TypeError: '<' not supported between instances of 'int' and 'str'
-
-    To avoid the exception, use a dictionary to assign priorities to the elements.
-
-    >>> q = MappedQueue({100: 0, "a": 1})
-
-    References
-    ----------
-    .. [1] Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2001).
-       Introduction to algorithms second edition.
-    .. [2] Knuth, D. E. (1997). The art of computer programming (Vol. 3).
-       Pearson Education.
-    """
-
-    def __init__(self, data=None):
-        """Priority queue class with updatable priorities."""
-        if data is None:
-            self.heap = []
-        elif isinstance(data, dict):
-            self.heap = [_HeapElement(v, k) for k, v in data.items()]
-        else:
-            self.heap = list(data)
-        self.position = {}
-        self._heapify()
-
-    def _heapify(self):
-        """Restore heap invariant and recalculate map."""
-        heapq.heapify(self.heap)
-        self.position = {elt: pos for pos, elt in enumerate(self.heap)}
-        if len(self.heap) != len(self.position):
-            raise AssertionError("Heap contains duplicate elements")
-
-    def __len__(self):
-        return len(self.heap)
-
-    def push(self, elt, priority=None):
-        """Add an element to the queue."""
-        if priority is not None:
-            elt = _HeapElement(priority, elt)
-        # If element is already in queue, do nothing
-        if elt in self.position:
-            return False
-        # Add element to heap and dict
-        pos = len(self.heap)
-        self.heap.append(elt)
-        self.position[elt] = pos
-        # Restore invariant by sifting down
-        self._siftdown(0, pos)
-        return True
-
-    def pop(self):
-        """Remove and return the smallest element in the queue."""
-        # Remove smallest element
-        elt = self.heap[0]
-        del self.position[elt]
-        # If elt is last item, remove and return
-        if len(self.heap) == 1:
-            self.heap.pop()
-            return elt
-        # Replace root with last element
-        last = self.heap.pop()
-        self.heap[0] = last
-        self.position[last] = 0
-        # Restore invariant by sifting up
-        self._siftup(0)
-        # Return smallest element
-        return elt
-
-    def update(self, elt, new, priority=None):
-        """Replace an element in the queue with a new one."""
-        if priority is not None:
-            new = _HeapElement(priority, new)
-        # Replace
-        pos = self.position[elt]
-        self.heap[pos] = new
-        del self.position[elt]
-        self.position[new] = pos
-        # Restore invariant by sifting up
-        self._siftup(pos)
-
-    def remove(self, elt):
-        """Remove an element from the queue."""
-        # Find and remove element
-        try:
-            pos = self.position[elt]
-            del self.position[elt]
-        except KeyError:
-            # Not in queue
-            raise
-        # If elt is last item, remove and return
-        if pos == len(self.heap) - 1:
-            self.heap.pop()
-            return
-        # Replace elt with last element
-        last = self.heap.pop()
-        self.heap[pos] = last
-        self.position[last] = pos
-        # Restore invariant by sifting up
-        self._siftup(pos)
-
-    def _siftup(self, pos):
-        """Move smaller child up until hitting a leaf.
-
-        Built to mimic code for heapq._siftup
-        only updating position dict too.
-        """
-        heap, position = self.heap, self.position
-        end_pos = len(heap)
-        startpos = pos
-        newitem = heap[pos]
-        # Shift up the smaller child until hitting a leaf
-        child_pos = (pos << 1) + 1  # start with leftmost child position
-        while child_pos < end_pos:
-            # Set child_pos to index of smaller child.
-            child = heap[child_pos]
-            right_pos = child_pos + 1
-            if right_pos < end_pos:
-                right = heap[right_pos]
-                if not child < right:
-                    child = right
-                    child_pos = right_pos
-            # Move the smaller child up.
-            heap[pos] = child
-            position[child] = pos
-            pos = child_pos
-            child_pos = (pos << 1) + 1
-        # pos is a leaf position. Put newitem there, and bubble it up
-        # to its final resting place (by sifting its parents down).
-        while pos > 0:
-            parent_pos = (pos - 1) >> 1
-            parent = heap[parent_pos]
-            if not newitem < parent:
-                break
-            heap[pos] = parent
-            position[parent] = pos
-            pos = parent_pos
-        heap[pos] = newitem
-        position[newitem] = pos
-
-    def _siftdown(self, start_pos, pos):
-        """Restore invariant. keep swapping with parent until smaller.
-
-        Built to mimic code for heapq._siftdown
-        only updating position dict too.
-        """
-        heap, position = self.heap, self.position
-        newitem = heap[pos]
-        # Follow the path to the root, moving parents down until finding a place
-        # newitem fits.
-        while pos > start_pos:
-            parent_pos = (pos - 1) >> 1
-            parent = heap[parent_pos]
-            if not newitem < parent:
-                break
-            heap[pos] = parent
-            position[parent] = pos
-            pos = parent_pos
-        heap[pos] = newitem
-        position[newitem] = pos