Inheritance diagram for DynamicIterationDict:

Collaboration diagram for DynamicIterationDict:

Public Member Functions
def	__init__ (self, initial=None, is_set=False, emquote=False, index=False)

def	__repr__ (self)

def	__str__ (self)

def	__contains__ (self, key)

def	__len__ (self)

def	__call__ (self, how_many_times=-1)

def	__iter__ (self)

def	__setitem__ (self, key, value)

def	__getitem__ (self, key)

def	__delitem__ (self, key)

def	trim_indexes_sorted (self)

def	trim_indexes_unsorted (self)

def	keys (self, how_many_times=-1)

def	values (self, how_many_times=-1)

def	items (self, how_many_times=-1)

def	get_key (self, index)

def	get_value (self, index)

def	get_key_value (self, index)

def	get_iterator (self, target_generation, how_many_times=-1)

def	not_iterate_over_new_items (self, how_many_times=1)

def	fromkeys (self, iterable)

def	append (self, element)

def	remove (self, element)

def	add (self, element)

def	discard (self, element)

def	copy (self)

def	clear (self)

Public Attributes
	keys_list
	The list with the keys of this collection elements.

	values_list
	The list with the elements of this collection.

	empty_slots
	List the empty free spots for old items, used globally before the iteration starts.

	filled_slots
	List the empty free spots for old items, used globally after the iteration starts with `new_items_skip_count`

	items_dictionary
	A dictionary with the indexes of the elements in this collection.

	new_items_skip_count
	Whether the iteration process is allowed to use new items added on the current iteration.

	new_items_skip_stack
	A stack of `new_items_skip_count` which is required when the current iterator is called recursively.

	maximum_iterable_index
	Holds the global maximum iterable index used when `new_items_skip_count` is set.

Detailed Description

    A `dict()` like object which allows to dynamically add and remove items while iterating over
    its elements as in `for element in dynamic_set`

    https://wiki.python.org/moin/TimeComplexity
    https://stackoverflow.com/questions/4014621/a-python-class-that-acts-like-dict

Definition at line 139 of file dynamic_iteration.py.

Constructor & Destructor Documentation

◆ init()

def __init__	(	self,
		initial = `None`,
		is_set = `False`,
		emquote = `False`,
		index = `False`
	)

    Fully initializes and create a new dictionary.

    @param `initial` is a dictionary used to initialize it with new values.

Definition at line 148 of file dynamic_iteration.py.

References DynamicIterationDict._is_set.

     def __init__(self, initial=None, is_set=False, emquote=False, index=False):
         """
             Fully initializes and create a new dictionary.
 
             @param `initial` is a dictionary used to initialize it with new values.
         """
 
         self._is_set = is_set
 
         self.keys_list = list()
 
         self.values_list = list()
 
         self._emquote_keys = emquote
 
         self._add_index = index
 
         self.empty_slots = set()
 
         self.filled_slots = set()
 
         self.items_dictionary = dict()
 
         self.new_items_skip_count = 0
 
         self.new_items_skip_stack = []
 
         self.maximum_iterable_index = [0]
 
         if initial:
 
             if isinstance( initial, dict ):
 
                 for key, value in initial.items():
                     self[key] = value
 
             else:
                 self.fromkeys( initial )

Member Function Documentation

◆ call()

def __call__	(	self,
		how_many_times = `-1`
	)

    Return a iterable for the keys elements of this collection when calling its object as a
    function call.

    `how_many_times` is for how many iterations it should keep ignoring the new items.

Definition at line 251 of file dynamic_iteration.py.

References DynamicIterationDict.get_iterator(), and DynamicIterationDict.get_key().

     def __call__(self, how_many_times=-1):
         """
             Return a iterable for the keys elements of this collection when calling its object as a
             function call.
 
             `how_many_times` is for how many iterations it should keep ignoring the new items.
         """
         return self.get_iterator( self.get_key, how_many_times )
 

Here is the call graph for this function:

◆ contains()

def __contains__	(	self,
		key
	)

    Determines whether this dictionary contains or not a given `key`.

Definition at line 239 of file dynamic_iteration.py.

References DynamicIterationDict.items_dictionary.

     def __contains__(self, key):
         """
             Determines whether this dictionary contains or not a given `key`.
         """
         return key in self.items_dictionary
 

◆ delitem()

def __delitem__	(	self,
		key
	)

    Given a `key` deletes if from this dict.

Definition at line 307 of file dynamic_iteration.py.

References DynamicIterationDict.add(), DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, and DynamicIterationDict.items_dictionary.

     def __delitem__(self, key):
         """
             Given a `key` deletes if from this dict.
         """
         # log( 1, "key: %s, self: %s", key, self )
         items_dictionary = self.items_dictionary
         item_index = items_dictionary[key]
 
         self.empty_slots.add( item_index )
         del items_dictionary[key]
 

Here is the call graph for this function:

◆ getitem()

def __getitem__	(	self,
		key
	)

    Given a `key` returns its existent value.

Definition at line 300 of file dynamic_iteration.py.

References DynamicIterationDict.items_dictionary, and DynamicIterationDict.values_list.

     def __getitem__(self, key):
         """
             Given a `key` returns its existent value.
         """
         # log( 1, "index: %s, key: %s", self.items_dictionary[key], key )
         return self.values_list[self.items_dictionary[key]]
 

◆ iter()

def __iter__ ( self )

    Called by Python automatically when iterating over this set and python wants to start
    the iteration process.

    Why have an __iter__ method in Python?
    https://stackoverflow.com/questions/36681312/why-have-an-iter-method-in-python

Definition at line 260 of file dynamic_iteration.py.

References DynamicIterationDict.get_iterator(), and DynamicIterationDict.get_key().

     def __iter__(self):
         """
             Called by Python automatically when iterating over this set and python wants to start
             the iteration process.
 
             Why have an __iter__ method in Python?
             https://stackoverflow.com/questions/36681312/why-have-an-iter-method-in-python
         """
         return self.get_iterator( self.get_key )
 

Here is the call graph for this function:

◆ len()

def __len__ ( self )

    Return the total length of this set.

Definition at line 245 of file dynamic_iteration.py.

References DynamicIterationDict.items_dictionary.

     def __len__(self):
         """
             Return the total length of this set.
         """
         return len( self.items_dictionary )
 

◆ repr()

def __repr__ ( self )

    Return a full representation of all public attributes of this object set state for
    debugging purposes.

Definition at line 198 of file dynamic_iteration.py.

Referenced by LockableType.__setattr__().

     def __repr__(self):
         """
             Return a full representation of all public attributes of this object set state for
             debugging purposes.
         """
         return get_representation( self )
 

Here is the caller graph for this function:

◆ setitem()

def __setitem__	(	self,
		key,
		value
	)

    Given a `key` and `item` add it to this dictionary as a non yet iterated item, replacing
    the existent value. It a iteration is running, and the item was already iterated, then
    it will be updated on the `niterated_items` dict.

Definition at line 270 of file dynamic_iteration.py.

References DynamicIterationDict.add(), DynamicIterationDict.append(), DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, DynamicIterable.filled_slots, DynamicIterationDict.filled_slots, DynamicIterationDict.items_dictionary, DynamicIterationDict.keys_list, DynamicIterationDict.new_items_skip_count, and DynamicIterationDict.values_list.

     def __setitem__(self, key, value):
         """
             Given a `key` and `item` add it to this dictionary as a non yet iterated item, replacing
             the existent value. It a iteration is running, and the item was already iterated, then
             it will be updated on the `niterated_items` dict.
         """
         items_dictionary = self.items_dictionary
 
         if key in items_dictionary:
             item_index = items_dictionary[key]
             self.values_list[item_index] = value
 
         else:
             empty_slots = self.empty_slots
             values_list = self.values_list
 
             if empty_slots and self.new_items_skip_count > 0:
                 free_slot = empty_slots.pop()
                 self.filled_slots.add( free_slot )
 
                 values_list[free_slot] = value
                 self.keys_list[free_slot] = key
 
             else:
                 free_slot = len( values_list )
                 values_list.append( value )
                 self.keys_list.append( key )
 
             self.items_dictionary[key] = free_slot
 

Here is the call graph for this function:

◆ str()

def __str__ ( self )

    Return a nice string representation of this collection.

Definition at line 205 of file dynamic_iteration.py.

References DynamicIterationDict._add_index, DynamicIterationDict._emquote_keys, DynamicIterationDict._is_set, DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, DynamicIterationDict.get_key(), DynamicIterationDict.keys(), DynamicIterationDict.keys_list, and DynamicIterationDict.values_list.

Referenced by LockableType.__repr__().

     def __str__(self):
         """
             Return a nice string representation of this collection.
         """
         keys_list = self.keys_list
         empty_slots = self.empty_slots
         representation = []
 
         if self._emquote_keys:
             get_key = lambda: emquote_string( key )
 
         else:
             get_key = lambda: key
 
         if self._add_index:
             get_index = lambda: "{}, {}".format( get_key(), index )
 
         else:
             get_index = get_key
 
         if self._is_set:
             return str( self.keys() )
 
         else:
             values_list = self.values_list
 
             for index in range( 0, len( keys_list ) ):
 
                 if index not in empty_slots:
                     key = keys_list[index]
                     representation.append( "%s: %s" % ( get_index(), values_list[index] ) )
 
         return "{%s}" % ", ".join( representation )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add()

def add	(	self,
		element
	)

    Add a new element to the end of the list.

Definition at line 468 of file dynamic_iteration.py.

Referenced by DynamicIterationDict.__delitem__(), and DynamicIterationDict.__setitem__().

     def add(self, element):
         """
             Add a new element to the end of the list.
         """
         self[element] = None
 

Here is the caller graph for this function:

◆ append()

def append	(	self,
		element
	)

    Add a new element to the end of the list.

Definition at line 456 of file dynamic_iteration.py.

Referenced by DynamicIterationDict.__setitem__(), and DynamicIterationDict.not_iterate_over_new_items().

     def append(self, element):
         """
             Add a new element to the end of the list.
         """
         self[element] = None
 

Here is the caller graph for this function:

◆ clear()

def clear ( self )

    Remove all items from this dict.

Definition at line 489 of file dynamic_iteration.py.

References DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, DynamicIterable.filled_slots, DynamicIterationDict.filled_slots, DynamicIterationDict.items_dictionary, DynamicIterationDict.keys_list, and DynamicIterationDict.values_list.

Referenced by SleepEvent.sleep(), and DynamicIterationDict.trim_indexes_sorted().

     def clear(self):
         """
             Remove all items from this dict.
         """
         self.empty_slots.clear()
         self.filled_slots.clear()
 
         self.keys_list.clear()
         self.values_list.clear()
         self.items_dictionary.clear()
 
 

Here is the caller graph for this function:

◆ copy()

def copy ( self )

    Return a deep copy of this collection.

Definition at line 483 of file dynamic_iteration.py.

     def copy(self):
         """
             Return a deep copy of this collection.
         """
         return copy.deepcopy( self )
 

◆ discard()

def discard	(	self,
		element
	)

    Remove new `element` anywhere in the container.

Definition at line 474 of file dynamic_iteration.py.

     def discard(self, element):
         """
             Remove new `element` anywhere in the container.
         """
         try:
             del self[element]
         except KeyError:
             pass
 

◆ fromkeys()

def fromkeys	(	self,
		iterable
	)

    Initialize a dictionary with None default value, acting like a indexed set.

Definition at line 448 of file dynamic_iteration.py.

     def fromkeys(self, iterable):
         """
             Initialize a dictionary with None default value, acting like a indexed set.
         """
 
         for key in iterable:
             self[key] = None
 

◆ get_iterator()

def get_iterator	(	self,
		target_generation,
		how_many_times = `-1`
	)

    Get fully configured iterable given the getter `target_generation(index)` function.

    `how_many_times` is for how many iterations it should keep ignoring the new items.

Definition at line 408 of file dynamic_iteration.py.

References DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, DynamicIterable.filled_slots, DynamicIterationDict.filled_slots, DynamicIterationDict.items_dictionary, DynamicIterationDict.maximum_iterable_index, DynamicIterationDict.new_items_skip_count, DynamicIterationDict.new_items_skip_stack, and DynamicIterationDict.not_iterate_over_new_items().

Referenced by DynamicIterationDict.__call__(), DynamicIterationDict.__iter__(), DynamicIterationDict.items(), DynamicIterationDict.keys(), and DynamicIterationDict.values().

     def get_iterator(self, target_generation, how_many_times=-1):
         """
             Get fully configured iterable given the getter `target_generation(index)` function.
 
             `how_many_times` is for how many iterations it should keep ignoring the new items.
         """
         self.new_items_skip_count -= 1
 
         # When the current sequence is exhausted, search for an old one
         if not self.new_items_skip_count > 0:
 
             # Unwind the stack until a valid item is found
             if self.new_items_skip_stack:
                 self.new_items_skip_count = self.new_items_skip_stack.pop()
 
         self.not_iterate_over_new_items( how_many_times )
 
         if self.new_items_skip_count > 0:
             return DynamicIterable( self.items_dictionary, target_generation, self.empty_slots, self.maximum_iterable_index, self.filled_slots )
 
         return DynamicIterable( self.items_dictionary, target_generation, self.empty_slots )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_key()

def get_key	(	self,
		index
	)

    Given a `index` returns its corresponding key.

Definition at line 390 of file dynamic_iteration.py.

References DynamicIterationDict.keys_list.

Referenced by DynamicIterationDict.__call__(), DynamicIterationDict.__iter__(), DynamicIterationDict.__str__(), and DynamicIterationDict.keys().

     def get_key(self, index):
         """
             Given a `index` returns its corresponding key.
         """
         return self.keys_list[index]
 

Here is the caller graph for this function:

◆ get_key_value()

def get_key_value	(	self,
		index
	)

    Given a `index` returns its corresponding (key, value) pair.

Definition at line 402 of file dynamic_iteration.py.

References DynamicIterationDict.keys_list, and DynamicIterationDict.values_list.

Referenced by DynamicIterationDict.items().

     def get_key_value(self, index):
         """
             Given a `index` returns its corresponding (key, value) pair.
         """
         return ( self.keys_list[index], self.values_list[index] )
 

Here is the caller graph for this function:

◆ get_value()

def get_value	(	self,
		index
	)

    Given a `index` returns its corresponding value.

Definition at line 396 of file dynamic_iteration.py.

References DynamicIterationDict.values_list.

Referenced by DynamicIterationDict.values().

     def get_value(self, index):
         """
             Given a `index` returns its corresponding value.
         """
         return self.values_list[index]
 

Here is the caller graph for this function:

◆ items()

def items	(	self,
		how_many_times = `-1`
	)

    Return a DynamicIterable over the (key, value) stored in this collection.

    `how_many_times` is for how many iterations it should keep ignoring the new items.

Definition at line 382 of file dynamic_iteration.py.

References DynamicIterationDict.get_iterator(), and DynamicIterationDict.get_key_value().

     def items(self, how_many_times=-1):
         """
             Return a DynamicIterable over the (key, value) stored in this collection.
 
             `how_many_times` is for how many iterations it should keep ignoring the new items.
         """
         return self.get_iterator( self.get_key_value, how_many_times )
 

Here is the call graph for this function:

◆ keys()

def keys	(	self,
		how_many_times = `-1`
	)

    Return a DynamicIterable over the keys stored in this collection.

    `how_many_times` is for how many iterations it should keep ignoring the new items.

Definition at line 366 of file dynamic_iteration.py.

References DynamicIterationDict.get_iterator(), and DynamicIterationDict.get_key().

Referenced by DynamicIterationDict.__str__().

     def keys(self, how_many_times=-1):
         """
             Return a DynamicIterable over the keys stored in this collection.
 
             `how_many_times` is for how many iterations it should keep ignoring the new items.
         """
         return self.get_iterator( self.get_key, how_many_times )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ not_iterate_over_new_items()

def not_iterate_over_new_items	(	self,
		how_many_times = `1`
	)

    If called before start iterating over this dictionary, it will not iterate over the
    new keys added until the current iteration is over.

    `how_many_times` is for how many iterations it should keep ignoring the new items.

Definition at line 430 of file dynamic_iteration.py.

References DynamicIterationDict.append(), DynamicIterable.filled_slots, DynamicIterationDict.filled_slots, DynamicIterationDict.keys_list, DynamicIterationDict.maximum_iterable_index, DynamicIterationDict.new_items_skip_count, and DynamicIterationDict.new_items_skip_stack.

Referenced by DynamicIterationDict.get_iterator().

     def not_iterate_over_new_items(self, how_many_times=1):
         """
             If called before start iterating over this dictionary, it will not iterate over the
             new keys added until the current iteration is over.
 
             `how_many_times` is for how many iterations it should keep ignoring the new items.
         """
 
         if how_many_times > 0:
 
             if self.new_items_skip_count > 0:
                 self.new_items_skip_stack.append( self.new_items_skip_count )
 
             self.filled_slots = set()
             self.new_items_skip_count = how_many_times
             self.maximum_iterable_index = [0]
             self.maximum_iterable_index[0] = len( self.keys_list )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove()

def remove	(	self,
		element
	)

    Remove new `element` anywhere in the container.

Definition at line 462 of file dynamic_iteration.py.

     def remove(self, element):
         """
             Remove new `element` anywhere in the container.
         """
         del self[element]
 

◆ trim_indexes_sorted()

def trim_indexes_sorted ( self )

    Fix the the outdated indexes on the internal lists after their dictionary removal,
    keeping the items original ordering O(n).

Definition at line 318 of file dynamic_iteration.py.

References DynamicIterationDict.clear(), DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, DynamicIterationDict.items_dictionary, DynamicIterationDict.keys_list, and DynamicIterationDict.values_list.

     def trim_indexes_sorted(self):
         """
             Fix the the outdated indexes on the internal lists after their dictionary removal,
             keeping the items original ordering O(n).
         """
         new_index = -1
         clean_keys = []
         clean_values = []
 
         values_list = self.values_list
         items_dictionary = self.items_dictionary
 
         for key, value_index in items_dictionary.items():
             new_index += 1
             items_dictionary[key] = new_index
             clean_keys.append( key )
             clean_values.append( values_list[value_index] )
 
         self.empty_slots.clear()
         self.keys_list = clean_keys
         self.values_list = clean_values
 

Here is the call graph for this function:

◆ trim_indexes_unsorted()

def trim_indexes_unsorted ( self )

    Fix the the outdated indexes on the internal lists after their dictionary removal.
    keeping the items original ordering O(k), where `k` is length of `self.empty_slots`.

Definition at line 340 of file dynamic_iteration.py.

References DynamicIterable.empty_slots, DynamicIterationDict.empty_slots, DynamicIterationDict.items_dictionary, DynamicIterationDict.keys_list, and DynamicIterationDict.values_list.

     def trim_indexes_unsorted(self):
         """
             Fix the the outdated indexes on the internal lists after their dictionary removal.
             keeping the items original ordering O(k), where `k` is length of `self.empty_slots`.
         """
         keys_list = self.keys_list
         values_list = self.values_list
         empty_slots = self.empty_slots
         last_slot = -1
 
         while empty_slots:
             empty_slot = empty_slots.pop()
             list_length = len( keys_list )
             key = keys_list.pop()
 
             keys_list[empty_slot] = key
             values_list[empty_slot] = values_list.pop()
             self.items_dictionary[key] = empty_slot
 
             if last_slot >= list_length:
                 last_slot = last_slot
 
         if last_slot > -1:
             del keys_list[last_slot:]
             del values_list[last_slot:]
 

◆ values()

def values	(	self,
		how_many_times = `-1`
	)

    Return a DynamicIterable over the values stored in this collection.

    `how_many_times` is for how many iterations it should keep ignoring the new items.

Definition at line 374 of file dynamic_iteration.py.

References DynamicIterationDict.get_iterator(), and DynamicIterationDict.get_value().

     def values(self, how_many_times=-1):
         """
             Return a DynamicIterable over the values stored in this collection.
 
             `how_many_times` is for how many iterations it should keep ignoring the new items.
         """
         return self.get_iterator( self.get_value, how_many_times )
 

Here is the call graph for this function:

The documentation for this class was generated from the following file:

dynamic_iteration.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __call__()

◆ __contains__()

◆ __delitem__()

◆ __getitem__()

◆ __iter__()

◆ __len__()

◆ __repr__()

◆ __setitem__()

◆ __str__()

◆ add()

◆ append()

◆ clear()

◆ copy()

◆ discard()

◆ fromkeys()

◆ get_iterator()

◆ get_key()

◆ get_key_value()

◆ get_value()

◆ items()

◆ keys()

◆ not_iterate_over_new_items()

◆ remove()

◆ trim_indexes_sorted()

◆ trim_indexes_unsorted()

◆ values()

◆ init()

◆ call()

◆ contains()

◆ delitem()

◆ getitem()

◆ iter()

◆ len()

◆ repr()

◆ setitem()

◆ str()