Can Protocol express conditional sorted() requirements without Any?

[hunterhogan]

In the function updateExtendPolishDictionaryLists, for the elements of the list, is it possible to use a type hint more specific than Any?

I would like to ask a better question, but I am struggling to discriminate the important concepts from everything else going on in the function.

I have essentially no experience with Protocol, but I've been using this prototype for a short while. On the other hand, I have literally only used it with non-negative int--that are less than 64.

(This package requires <= Python 3.12:)

from cytoolz.functoolz import curry as syntacticCurry
from typing import Protocol

class Ordinals(Protocol):
	"""Protocol for types that support ordering comparisons."""

	def __le__(self, other: "Ordinals", /) -> bool:
		"""Less than or equal to comparison."""
		...
	def __ge__(self, other: "Ordinals", /) -> bool:
		"""Greater than or equal to comparison."""
		...

@syntacticCurry
def between[小于: Ordinals](floor: 小于, ceiling: 小于, comparand: 小于) -> bool:
	"""Inclusive `floor <= comparand <= ceiling`."""
	return floor <= comparand <= ceiling

If possible, I would like to improve the type hints in updateExtendPolishDictionaryLists, but I can't find the right combination. If I change ePluribusUnum from dict[..., list[...]] to Sequence[...], then .extend complains about not being a list, and I don't know how to fix that, even though I suspect it is easy.

I've tried different combinations of Mapping, Sequence, and using the Union operator. This answer is thorough and clear, and I almost understand it, but I can't figure out if it is or isn't relevant to my goal.

Similarly, I think I understand at least half of this discussion about SupportsRichComparison, and maybe it means I can't be more specific than Any, but I'm not sure.

I tried this silliness:

	if reorderLists:
		ePluribusUnum: dict[str, list[小于]] = {}
	else:
		ePluribusUnum: dict[str, list[个]] = {}

It doesn't work, of course, because 'Declaration "ePluribusUnum" is obscured by a declaration of the same name.'

This issue is not critical, which is why I hope it is a good way for me to learn more: less pressure.

This package requires <= Python 3.11:

from typing import Literal, overload, Protocol, TYPE_CHECKING, TypeVar

if TYPE_CHECKING:
	from collections.abc import Sequence

class Ordinals(Protocol):
	"""Protocol for types that support ordering comparisons."""

	def __le__(self, other: "Ordinals", /) -> bool:
		"""Less than or equal to comparison."""
		...
	def __ge__(self, other: "Ordinals", /) -> bool:
		"""Greater than or equal to comparison."""
		...

个 = TypeVar('个')
小于 = TypeVar('小于', bound=Ordinals)

@overload
def updateExtendPolishDictionaryLists(
	*dictionaryLists: Mapping[str, list[小于] | set[小于] | tuple[小于, ...]]
	, destroyDuplicates: bool = False
	, reorderLists: Literal[True] = True
	, killErroneousDataTypes: bool = False
	) -> dict[str, list[小于]]: ...
@overload
def updateExtendPolishDictionaryLists(
	*dictionaryLists: Mapping[str, list[个] | set[个] | tuple[个, ...]]
	, destroyDuplicates: bool = False
	, reorderLists: Literal[False] = False
	, killErroneousDataTypes: bool = False
	) -> dict[str, list[个]]: ...
def updateExtendPolishDictionaryLists(
	*dictionaryLists: Mapping[str, list[个] | set[个] | tuple[个, ...]] | Mapping[str, list[小于] | set[小于] | tuple[小于, ...]]
	, destroyDuplicates: bool = False
	, reorderLists: bool = False
	, killErroneousDataTypes: bool = False
	) -> dict[str, list[个]] | dict[str, list[小于]]:
	"""Merge multiple dictionaries with `list` values into a single dictionary with the `list` values merged.

	Plus options to destroy duplicates, sort `list` values, and handle erroneous data types.

	Parameters
	----------
	*dictionaryLists : Mapping[str, list[Any] | set[Any] | tuple[Any, ...]]
		Variable number of dictionaries to be merged. If only one dictionary is passed, it will be "polished".
	destroyDuplicates : bool = False
		If `True`, removes duplicate elements from the `list`. Defaults to `False`.
	reorderLists : bool = False
		If `True`, sorts each `list` value. Defaults to `False`. The elements must be comparable; otherwise, a `TypeError` will be raised.
	killErroneousDataTypes : bool = False
		If `True`, suppresses any `TypeError` `Exception` and omits the dictionary key or value that caused the `Exception`.
		Defaults to `False`.

	Returns
	-------
	ePluribusUnum : dict[str, list[Any]]
		A single dictionary with merged and optionally "polished" `list` values.

	Notes
	-----
	The returned value, `ePluribusUnum`, is a so-called primitive dictionary (`dict`). Furthermore, every dictionary key is a
	so-called primitive string (*cf.* `str()`) and every dictionary value is a so-called primitive `list` (`list`). If
	`dictionaryLists` has other data types, the data types will not be preserved. That could have unexpected consequences.
	Conversion from the original data type to a `list`, for example, may not preserve the order even if you want the order to be
	preserved.

	"""
	ePluribusUnum: dict[str, list[个]] | dict[str, list[小于]] = {}

	for dictionaryListTarget in dictionaryLists:
		for keyName, keyValue in dictionaryListTarget.items():
			try:
				ImaStr = str(keyName)
				ImaList: Sequence[个 | 小于] = list(keyValue)
				ePluribusUnum.setdefault(ImaStr, []).extend(ImaList)
			except TypeError:
				if killErroneousDataTypes:
					continue
				else:
					raise

	if destroyDuplicates:
		for ImaStr, ImaList in ePluribusUnum.items():
			ePluribusUnum[ImaStr] = list(dict.fromkeys(ImaList))
	if reorderLists:
		for ImaStr, ImaRichComparisonSupporter in ePluribusUnum.items():
			ePluribusUnum[ImaStr] = sorted(ImaRichComparisonSupporter)

	return ePluribusUnum

The two diagnostic messages

Argument of type "list[个@updateExtendPolishDictionaryLists | 小于@updateExtendPolishDictionaryLists]" cannot be assigned to parameter "iterable" of type "Iterable[个@updateExtendPolishDictionaryLists]" in function "extend"
  "list[个@updateExtendPolishDictionaryLists | 小于@updateExtendPolishDictionaryLists]" is not assignable to "Iterable[个@updateExtendPolishDictionaryLists]"
    Type parameter "_T_co@Iterable" is covariant, but "个@updateExtendPolishDictionaryLists | 小于@updateExtendPolishDictionaryLists" is not a subtype of "个@updateExtendPolishDictionaryLists"
      Type "个@updateExtendPolishDictionaryLists | 小于@updateExtendPolishDictionaryLists" is not assignable to type "个@updateExtendPolishDictionaryLists"

Argument of type "list[个@updateExtendPolishDictionaryLists]" cannot be assigned to parameter "iterable" of type "Iterable[SupportsRichComparisonT@sorted]" in function "sorted"
  "list[个@updateExtendPolishDictionaryLists]" is not assignable to "Iterable[SupportsRichComparisonT@sorted]"
    Type parameter "_T_co@Iterable" is covariant, but "个@updateExtendPolishDictionaryLists" is not a subtype of "SupportsRichComparisonT@sorted"
      Type "个@updateExtendPolishDictionaryLists" is not assignable to type "SupportsRichComparison"
        Type "个@updateExtendPolishDictionaryLists" is not assignable to type "SupportsRichComparison"
          "object*" is incompatible with protocol "SupportsDunderLT[Any]"
          "object*" is incompatible with protocol "SupportsDunderGT[Any]"