F2j'ddlmZddlmZddlmZmZmZddlm Z erddl m Z m Z  ddlm Z n#e$r ddlm Z YnwxYwedZedZ dddZ dddZGddeZgdZd S)) annotations) OrderedDict) TYPE_CHECKINGAnyTypeVar) to_unicode)IterableMapping)SelfKTVTNkeys Iterable[KT]canonical_orderIterable[KT] | Nonereturnlist[KT]cdt|pgDfd|D}fd|D}t|fdt|zS)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'] ci|]\}}|| Sr).0iks ^/home/thesage/.hermes/hermes-agent/venv/lib/python3.11/site-packages/icalendar/caselessdict.py z"canonsort_keys..-sGGGdaQGGGcg|]}|v| Srrrr canonical_maps r z"canonsort_keys...s# 2 2 2!qM11A111rcg|]}|v| Srrrs rr z"canonsort_keys../s# 6 6 6!q 55A555rc|SNr)rrs rz canonsort_keys..0s mA&6r)key) enumeratesorted)rrheadtailrs @rcanonsort_keysr*s2HGi0E2&F&FGGGM 2 2 2 2t 2 2 2D 6 6 6 6t 6 6 6D $6666 7 7 7&,, FFrdict1Mapping[KT, VT]list[tuple[KT, VT]]c`fdt|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)] c$g|] }||f Srr)rrr+s rr z#canonsort_items..Gs! Q Q QaQaM Q Q Qr)r*r)r+rs` rcanonsort_itemsr03s2( R Q Q Q>%**,,#P#P Q Q QQrceZdZdZd$fd ZdZd%fd Zd&fd Zd'fd Zd(fd Z d)d*fd Z d)d+fd Z d)d*fd Z d,fd Z d(fd Zd$dZd-fd Zd.dZd/dZd/dZdZd0d!Zd1d#ZxZS)2 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. argsrkwargsrNonectj|i||D]R\}}t|}||kr&t||||<SdS)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__)selfr3r4r%value key_upper __class__s rr8zCaselessDict.__init__Ss$ $)&)))**,, ( (JC"3--//Ii##C((("'Y  ( (rNr%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. )rr7 __getitem__r:r<r%r?s rrAzCaselessDict.__getitem__ns0ooww""399;;///rr=ct|}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)rr7 __setitem__r:r<r%r=r?s rrDzCaselessDict.__setitem__~s8oo CIIKK/////rct|}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)rr7r;r:rBs rr;zCaselessDict.__delitem__s6oo CIIKK(((((rboolct|}t|S)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``. rr7 __contains__r:rBs rrJzCaselessDict.__contains__s0ooww##CIIKK000rdefaultct|}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``. )rr7getr:r<r%rKr?s rrMzCaselessDict.get0ooww{{399;;000rct|}t||S)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. )rr7 setdefaultr:rEs rrQzCaselessDict.setdefaults2ooww!!#))++u555rct|}t||S)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``. )rr7popr:rNs rrSzCaselessDict.poprOrtuple[Any, Any]cDtS)zRemove and return the last inserted (key, value) pair. Returns: A (key, value) tuple. Raises: KeyError: If the dictionary is empty. )r7popitemr<r?s rrVzCaselessDict.popitemsww   rct|}t|S)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``. rIrBs rhas_keyzCaselessDict.has_keys0ooww##CIIKK000rct||gz}|D]@}t|dr!t|}|D] \}}|||< AdS)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. r9N)listhasattriterr9)r<r3r4mappingsmappingr%r=s rupdatezCaselessDict.updatesy::( " "Gw(( 0w}}//% " " U!S  " " "rr cpt|tS)zReturn a shallow copy of the dictionary. Returns: A new instance of the same type with the same contents. )typer7copyrWs rrczCaselessDict.copys' tDzz%'',,..)))rstrcPt|jdt|dS)zReturn a string representation of the dictionary. Returns: A string in the form ``CaselessDict({...})``. ())rb__name__dictr<s r__repr__zCaselessDict.__repr__s* t**%55T 5555rotherobjectct|tstS||upCt|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``. ) isinstanceriNotImplementedr9r<rls r__eq__zCaselessDict.__eq__sP%&& "! !u}ITZZ\\ 2 2d5;;==6I6I IIrc||k S)zCheck inequality with another dictionary. Parameters: other: The object to compare. Returns: ``True`` if not equal, else ``False``. rrqs r__ne__zCaselessDict.__ne__s5=  r list[str]cPt||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*rrrjs r sorted_keyszCaselessDict.sorted_keys$sdiikk4+?@@@rlist[tuple[Any, Any]]c,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. )r0rrjs r sorted_itemszCaselessDict.sorted_items/stT%9:::r)r3rr4rrr5)r%rrr)r%rr=rrr5)r%rrr5)r%rrrGr#)r%rrKrrr)r%rr=rrr)rrT)rr )rrd)rlrmrrG)rru)rrx)rh __module__ __qualname____doc__r8__hash__rArDr;rJrMrQrSrVrYr`rcrkrrrtrrwrz __classcell__)r?s@rr2r2Js((((((2H000000 000000 ) ) ) ) ) ) 1 1 1 1 1 1 1 1 1 1 1 1 1 6 6 6 6 6 6 6 1 1 1 1 1 1 1 ! ! ! ! ! ! 1 1 1 1 1 1""""$******6666JJJJ" ! ! ! !O A A A A ; ; ; ; ; ; ; ;rr2)r2r0r*r#)rrrrrr)r+r,rrrr-) __future__r collectionsrtypingrrricalendar.parser_toolsrcollections.abcr r r ImportErrortyping_extensionsr r r*r0r2__all__rrrrsr""""""######..........------211111111''''&&&&&&&&' WT]] WT]]@DGGGGG@DHRRRRR.n;n;n;n;n;;n;n;n;b @ ? ?s / ==