Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- frozen_pair_source_t = TypeVar('frozen_pair_source_t', bound = Enum)
- frozen_pair_output_t = TypeVar('frozen_pair_output_t')
- frozen_pair_return_t = NewType('frozen_pair_return_t', Tuple[FrozenSet[frozen_pair_source_t], Mapping[frozen_pair_source_t, frozen_pair_output_t]])
- frozen_pair_key_value_t = NewType('frozen_pair_key_value_t', Tuple[frozen_pair_source_t, frozen_pair_output_t])
- def gen_frozen_set_dict_pair(source_enum: Type[frozen_pair_source_t], key_value_pairs: Iterable[frozen_pair_key_value_t], converge_keys: bool, converge_values: bool,
- finalize_value_entry: Callable[[frozen_pair_source_t, Iterable[frozen_pair_output_t]], frozen_pair_output_t] = None,
- finalize_key_entry: Callable[[frozen_pair_output_t, Iterable[frozen_pair_source_t]], frozen_pair_source_t] = None) -> frozen_pair_return_t:
- """Generate a frozen set and a frozen dictionary based on the provided input parameters.
- Parameters:
- - source_enum (Type[frozen_pair_source_t]): The type of the source enum. This defines the valid keys for the resulting dictionary.
- - key_value_pairs (Iterable[frozen_pair_key_value_t]): An iterable containing key-value pairs. Each pair is a tuple containing a source enum value and an output value.
- - converge_keys (bool): If set to True, the function will converge the keys. This means that for each key in the source enum, the function will associate/link the key itself to its associated values in the dictionary, mapping them to it.
- - converge_values (bool): If set to True, the function will converge the values. This means that for each value associated with a key, the function will associate the value itself to its associated keys in the dictionary, mapping them to it.
- - finalize_value_entry (Callable): An optional function that finalizes the value entry. It takes a key and an iterable of its associated values and returns the finalized value for that key.
- - finalize_key_entry (Callable): An optional function that finalizes the key entry. It takes a value and an iterable of its associated keys and returns the finalized key for that value.
- Logic:
- 1. Convert the parts iterable into a tuple.
- 2. Filter out valid parts from the tuple based on the source enum.
- 3. Initialize a dictionary to store the relationships between keys and values.
- 4. Populate the dictionary based on the filtered parts.
- 5. If converge_keys is True, converge the keys.
- 6. If converge_values is True, converge the values.
- 7. Finalize the value entries using the provided finalize_value_entry function.
- 8. Finalize the key entries using the provided finalize_key_entry function.
- 9. Return a frozen set of keys and a frozen dictionary.
- Returns:
- - frozen_pair_return_t: A tuple containing a frozen set of keys and a frozen dictionary.
- Usage:
- ```python3
- class SampleEnum(Enum):
- A = "A"
- B = "B"
- # Use the function
- frozen_set, frozen_dict = gen_frozen_set_dict_pair(SampleEnum, [("A", "X"), ("B", "Y")], True, True)
- ```
- Suggested Use Cases:
- - When you need to create an immutable mapping between a set of keys and values and want the flexibility to converge keys and values.
- - In scenarios where you want to ensure type safety and clarity in the function's expected inputs and outputs using type annotations.
- - When working with data that should not be modified after its creation, ensuring data integrity.
- """
- net_of_parts: Tuple[frozen_pair_key_value_t, ...] = tuple(x_part for x_part in key_value_pairs if isinstance(x_part, tuple) and len(x_part) == 2 and x_part[0] in source_enum)
- build_table: Dict[frozen_pair_source_t, Deque[frozen_pair_output_t]] = defaultdict(deque)
- for key, value in net_of_parts:
- build_table[key].append(value)
- set_of_a_keys: Set[frozen_pair_source_t] = set(key for key, _ in net_of_parts)
- set_of_b_keys: Set[frozen_pair_output_t] = set(value for _, value in net_of_parts)
- if converge_keys:
- for key in set_of_a_keys:
- for vx in build_table[key]:
- build_table[vx].append(key)
- if converge_values:
- for value in set_of_b_keys:
- for kx in build_table[value]:
- build_table[kx].append(value)
- if finalize_value_entry is None:
- for key in set_of_a_keys:
- value_queue = build_table[key]
- if len(value_queue) == 1:
- build_table[key] = value_queue.pop()
- elif len(value_queue) > 1:
- build_table[key] = tuple(value_queue)
- else:
- del build_table[key]
- else:
- for key in set_of_a_keys:
- build_table[key] = finalize_value_entry(key, iter(build_table[key]))
- if finalize_key_entry is None:
- for value in set_of_b_keys:
- key_queue = build_table[value]
- if len(key_queue) == 1:
- build_table[value] = key_queue.pop()
- elif len(key_queue) > 1:
- build_table[value] = tuple(key_queue)
- else:
- del build_table[value]
- else:
- for value in set_of_b_keys:
- build_table[value] = finalize_value_entry(value, iter(build_table[value]))
- return frozenset(set_of_a_keys), frozendict(build_table)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement