o .j'@sddlmZddlmZddlmZmZmZddlm Z er&ddl m Z m Z zddlm Z Wney=ddlm Z YnwedZedZ ddddZ ddddZGdddeZgdZd S)) annotations) OrderedDict) TYPE_CHECKINGAnyTypeVar) to_unicode)IterableMapping)SelfKTVTNkeys Iterable[KT]canonical_orderIterable[KT] | Nonereturnlist[KT]csVddt|pgDfdd|D}fdd|D}t|fdddt|S) aSort leading keys according to a canonical order. Keys specified in ``canonical_order`` appear first in that order. Remaining keys appear alphabetically at the end. Parameters: keys: The keys to sort. canonical_order: The preferred order for leading keys. Keys not in this sequence are sorted alphabetically after the canonical ones. If ``None``, all keys are sorted alphabetically. Returns: A new list of keys sorted by canonical order first, then alphabetically. Example: .. code-block:: pycon >>> from icalendar.caselessdict import canonsort_keys >>> canonsort_keys(["C", "A", "B"], ["B", "C"]) ['B', 'C', 'A'] cSsi|]\}}||qSr).0ikrrK/home/thesage/.local/lib/python3.10/site-packages/icalendar/caselessdict.py -sz"canonsort_keys..csg|]}|vr|qSrrrr canonical_maprr .z"canonsort_keys..csg|]}|vr|qSrrrrrrr/rcs|SNr)rrrr0sz canonsort_keys..)key) enumeratesorted)r rheadtailrrrcanonsort_keyssr%dict1Mapping[KT, VT]list[tuple[KT, VT]]csfddt|DS)a4Sort items from a mapping according to a canonical key order. Parameters: dict1: The mapping whose items to sort. canonical_order: The preferred order for leading keys. If ``None``, all keys are sorted alphabetically. Returns: A list of ``(key, value)`` tuples sorted by canonical order. Example: .. code-block:: pycon >>> from icalendar.caselessdict import canonsort_items >>> canonsort_items({"C": 3, "A": 1, "B": 2}, ["B", "C"]) [('B', 2), ('C', 3), ('A', 1)] csg|]}||fqSrrrr&rrrGrz#canonsort_items..)r%r )r&rrr)rcanonsort_items3sr*cseZdZdZd5fdd Zd Zd6fd d Zd7fdd Zd8fdd Zd9fdd Z d:d;fdd Z d:d<fdd Z d:d;fdd Z d=fdd Z d9fdd Zd5d!d"Zd>fd$d% Zd?d'd(Zd@d+d,Zd@d-d.Zd ZdAd0d1ZdBd3d4ZZS)C CaselessDicta>A case-insensitive dictionary that uses strings as keys. All keys are stored in uppercase internally, but values retain their original case. Keys can be provided as ``str`` or ``bytes``. They are converted to Unicode via :func:`~icalendar.parser_tools.to_unicode`, then uppercased before storage. argsrkwargsrNonecsPtj|i||D]\}}t|}||kr%t||||<q dS)a9Parameters: *args: Positional arguments passed to :class:`~collections.OrderedDict`. **kwargs: Keyword arguments passed to :class:`~collections.OrderedDict`. Example: Create a new ``CaselessDict`` and normalize existing keys to uppercase. .. code-block:: pycon >>> from icalendar.caselessdict import CaselessDict >>> d = CaselessDict(summary="Meeting") >>> d["SUMMARY"] 'Meeting' >>> "summary" in d True N)super__init__itemsrupper __delitem__)selfr,r-r value key_upper __class__rrr0Ss  zCaselessDict.__init__Nr ct|}t|S)aFGet the item from the ``CaselessDict`` instance by ``key``, case-insensitively. Parameters: key: The key to look up, case-insensitively. Returns: The (key, value) pair associated with the uppercased key. Raises: KeyError: If the key is not found. )rr/ __getitem__r2r4r r7rrr:ns zCaselessDict.__getitem__r5cst|}t||dS)zSet a (key, value) pair, storing the key in uppercase. Parameters: key: The key of the pair, case-insensitive. value: The value to associate with the key. N)rr/ __setitem__r2r4r r5r7rrr<~szCaselessDict.__setitem__cst|}t|dS)zDelete a (key, value) pair by its case-insensitive key. Parameters: key: The key to delete, case-insensitively. Raises: KeyError: If the key is not found. N)rr/r3r2r;r7rrr3s zCaselessDict.__delitem__boolcr9)zCheck whether a key exists in the mapping, case-insensitively. Parameters: key: The key to check case-insensitively. Returns: ``True`` if the uppercased key exists, else ``False``. rr/ __contains__r2r;r7rrr@s zCaselessDict.__contains__defaultct|}t||S)a;Return the ``key``, optionally with a ``default`` value. Parameters: key: The key to look up, case-insensitively. default: The value to return if the key is not found. Returns: The value for the key, if present, else the value specified by ``default``. )rr/getr2r4r rAr7rrrC zCaselessDict.getcrB)aUCreate the (key, value) pair, optionally with a ``value``. Once set, to change default value use :meth:`update`. Parameters: key: The key to look up or create, case-insensitively. value: The default value to set, if given, else ``None``. Returns: The value for the key. )rr/ setdefaultr2r=r7rrrFs zCaselessDict.setdefaultcrB)a+Remove and return the value for ``key``, or ``default`` if not found. Parameters: key: The key to remove, case-insensitively. default: The value to return if the key is not found. Returns: The removed value, or the value of ``default``. )rr/popr2rDr7rrrGrEzCaselessDict.poptuple[Any, Any]cs tS)zRemove and return the last inserted (key, value) pair. Returns: A (key, value) tuple. Raises: KeyError: If the dictionary is empty. )r/popitemr4r7rrrI zCaselessDict.popitemcr9)a Check whether a key exists, case-insensitively. This is a legacy method. Use ``key in dict`` instead. Parameters: key: The key to check, case-insensitively. Returns: ``True`` if the key exists, else ``False``. r?r;r7rrhas_keys zCaselessDict.has_keycOsHt||g}|D]}t|drt|}|D]\}}|||<qq dS)aTUpdate the dictionary with (key, value) pairs, normalizing keys to uppercase. Multiple keys that differ only in case will overwrite each other. Only the last value is retained. Parameters: *args: Mappings or iterables of (key, value) pairs. **kwargs: Additional (key, value) pairs. r1N)listhasattriterr1)r4r,r-mappingsmappingr r5rrrupdates     zCaselessDict.updater cst|tS)zReturn a shallow copy of the dictionary. Returns: A new instance of the same type with the same contents. )typer/copyrJr7rrrTszCaselessDict.copystrcCst|jdt|dS)zReturn a string representation of the dictionary. Returns: A string in the form ``CaselessDict({...})``. ())rS__name__dictrJrrr__repr__szCaselessDict.__repr__otherobjectcCs.t|tstS||upt|t|kS)aCheck equality with another dictionary. Two ``CaselessDict`` instances are equal if they contain the same (key, value) pairs after uppercasing keys. Comparison with a regular ``dict`` also works. Parameters: other: The object to compare. Returns: ``True`` if equal, ``NotImplemented`` if ``other`` is not a ``dict``. ) isinstancerYNotImplementedr1r4r[rrr__eq__s  zCaselessDict.__eq__cCs ||k S)zCheck inequality with another dictionary. Parameters: other: The object to compare. Returns: ``True`` if not equal, else ``False``. rr_rrr__ne__rKzCaselessDict.__ne__ list[str]cCst||jS)zSort keys according to the canonical order for this class. Keys listed in :attr:`canonical_order` appear first in that order. Remaining keys appear alphabetically at the end. Returns: A sorted list of keys. )r%r rrJrrr sorted_keys$s zCaselessDict.sorted_keyslist[tuple[Any, Any]]cCs t||jS)aSort items according to the canonical order for this class. Items whose keys are listed in :attr:`canonical_order` appear first in that order. Remaining items appear alphabetically by key. Returns: A sorted list of (key, value) tuples. )r*rrJrrr sorted_items/s zCaselessDict.sorted_items)r,rr-rrr.)r rrr)r rr5rrr.)r rrr.)r rrr>r)r rrArrr)r rr5rrr)rrH)rr )rrU)r[r\rr>)rrb)rrd)rX __module__ __qualname____doc__r0__hash__r:r<r3r@rCrFrGrIrLrRrTrZr`rarrcre __classcell__rrr7rr+Js*           r+)r+r*r%r)r rrrrr)r&r'rrrr() __future__r collectionsrtypingrrricalendar.parser_toolsrcollections.abcrr r ImportErrortyping_extensionsr r r%r*r+__all__rrrrs(      r