eule package

Submodules

eule.core module

Main module.

class eule.core.Euler(sets: Union[List, Dict])[source]

Bases: object

as_dict()[source]

Get the Euler set representation as a dictionary.

Returns: dict: The Euler set representation as a dictionary.

euler_boundaries()[source]

Get the boundaries of the Euler set representation.

Returns: tuple: A tuple containing the lower and upper boundaries of the Euler set representation.

euler_keys()[source]

Get the keys associated with the Euler set representation.

Returns: list: A list of keys corresponding to the Euler set representation.

match(items: set)[source]

Match a set of items to the sets in the Euler representation.

Parameters: items (set): A set of items to match against the sets in the Euler representation.

Returns: set: A set of keys corresponding to sets that are subsets of the provided items.

It checks which sets in the Euler representation are subsets of the provided items and returns their keys.

remove_key(key)[source]

Remove a key from the sets in the Euler representation.

Parameters: key: The key to be removed from the sets.

If the key exists, it is removed from the sets, and the Euler representation is updated. If the key doesn’t exist, a warning is issued.

eule.core.euler(sets: Union[List[Union[List, Set]], Dict[Union[str, Tuple], Union[List, Set]]])[source]

Euler diagram dictionary of set-dictionary of non-repetitive elements

Parameters:: sets (dict) – array/dict of arrays
Returns:: euler sets
Return type:: dict

eule.core.euler_boundaries(sets)[source]

Euler diagram set boundaries

Parameters:: sets (dict) – array/dict of arrays
Returns:: euler boundary dict
Return type:: list

eule.core.euler_generator(sets: Union[List[Union[List, Set]], Dict[Union[str, Tuple], Union[List, Set]]])[source]

This generator function returns each tuple (key, elems) of the Euler diagram in a generator-wise fashion systematic:

Begin with the available sets and their exclusive elements;
Compute complementary elements to the current key-set;
In case complementary set-keys AND current set content are not empty, continue;
Otherwise, go to the next key-set;
Find the euler diagram on complementary sets;
Compute exclusive combination elements;
In case there are exclusive elements to the combination: yield exclusive combination elements; Remove exclusive combination elements from the current key-set.

Parameters:: sets (dict) – array/dict of arrays
Returns:: (key, euler_set) tuple of given sets
Return type:: tuple

eule.core.euler_keys(sets: Union[List[Union[List, Set]], Dict[Union[str, Tuple], Union[List, Set]]])[source]

Euler diagram keys

Parameters:: sets (dict) – array/dict of arrays
Returns:: euler sets keys
Return type:: list

eule.utils module

utils module.

eule.utils.clear_sets(sets: Union[List[Union[List, Set]], Dict[Union[str, Tuple], Union[List, Set]]])[source]

This map returns a set with non-empty values

Parameters:: set (dict) –
Returns:: a set universe with
Return type:: dict

eule.utils.cleared_set_keys(candidate: Union[List[Union[List, Set]], Dict[Union[str, Tuple], Union[List, Set]]])[source]

This map returns a set with non-empty values

Parameters:: set (dict) –
Returns:: a set universe with
Return type:: dict

eule.utils.ordenate_tuple(tuple_: Tuple)[source]

This map returns a sorted tuple element on given candidate

Parameters:

input_tuple (tuple) – The original tuple to be updated.
value (Any) – The element to be added to the tuple.

Returns:

An ordered and updated tuple.

Return type:

tuple

eule.utils.ordered_tuplify(candidate: Union[str, List, Tuple]) → Tuple[source]

This map returns a sorted tuple element on given candidate

Parameters:: candidate – tuplification candidate
Returns:: tuple with sorted elements
Return type:: tuple

eule.utils.reduc(func: Callable[[Any, Any], Any], elems: Iterable[Any], elem0: Any) → Any[source]

This function returns a reduce handler

Parameters:

func (function) – Reduce callback
elems (dict) – list of elements
elem0 (dict) – first elements

eule.utils.sequence_to_set(sequence: Union[List, Tuple, Set])[source]

This map converts a list or a tuple into a set

Parameters:: elements (list or tuple of) –
Returns:: a set-converted sequence
Return type:: set

eule.utils.setify_sequences(sequence_list: List[Union[List, Tuple, Set]]) → Tuple[Set][source]

This map returns a set of sets

Parameters:: sets (list of) –
Returns:: set of sets
Return type:: tuple

eule.utils.tuplify(candidate: Union[str, List, Tuple])[source]

This map returns a tuple element on given candidate

Parameters:: candidate – tuplification candidate
Returns:: string with sorted elements delimited by given delimiter
Return type:: str

eule.utils.uniq(lst: List)[source]

This map returns list with unique elements

Parameters:: lst (list) – array of elements entries
Returns:: list with unique elements
Return type:: list

eule.utils.update_ordered_tuple(candidate: Tuple, value: Any) → Tuple[source]

This map returns a sorted tuple element on given candidate

Parameters:: candidate – tuplification candidate
Returns:: tuple with sorted elements
Return type:: tuple

eule.utils.update_tuple(tuple_: Tuple, value: Any)[source]

This map updates and sorts a tuple with a value

Parameters:

elements (tuple of) –
value – element to update

Returns:

an ordered and updated tuple

Return type:

tuple

Module contents

Package Eule