՟fndZddlZddlZddlZddlZddlmZddlmZddlm Z ddl m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$erdd l%m&Z&edddZ'GddZ(y)z Base class for Telegram Objects.N)Sized)contextmanager)deepcopy)chain)MappingProxyType) TYPE_CHECKINGAnyClassVarDictIteratorListMappingOptionalSetTupleTypeTypeVarUnioncast) to_timestamp) DefaultValue)JSONDict)warn)BotTele_coTelegramObjectT)bound covariantceZdZUdZdZeZeee e d<dZ e e de d<ddde eddfd Zd edeffd Zdeffd Zd e deddffd Zd e ddffd Zde fdZde defdZdee ee efffdZdee efddfdZdedeeefdefdZede ede efdZ e! d1de ede ede dde ede ef dZ"e! d1de ede ede dde efd Z#e! d1de ede e$ede dde%ed!ffd"Z&e'dede(efd#Z)d2d$Z*d2d%Z+deddfd&Z,d'ede(e fd(Z- d3d'ed)ed*ed+edee ee efff d,Z.de fd-Z/d4d)edefd.Z0d5d/Z1de dddfd0Z2xZ3S)6raBase class for most Telegram objects. Objects of this type are subscriptable with strings. See :meth:`__getitem__` for more details. The :mod:`pickle` and :func:`~copy.deepcopy` behavior of objects of this type are defined by :meth:`__getstate__`, :meth:`__setstate__` and :meth:`__deepcopy__`. Tip: Objects of this type can be serialized via Python's :mod:`pickle` module and pickled objects from one version of PTB are usually loadable in future versions. However, we can not guarantee that this compatibility will always be provided. At least a manual one-time conversion of the data may be needed on major updates of the library. .. versionchanged:: 20.0 * Removed argument and attribute ``bot`` for several subclasses. Use :meth:`set_bot` and :meth:`get_bot` instead. * Removed the possibility to pass arbitrary keyword arguments for several subclasses. * String representations objects of this type was overhauled. See :meth:`__repr__` for details. As this class doesn't implement :meth:`object.__str__`, the default implementation will be used, which is equivalent to :meth:`__repr__`. * Objects of this class (or subclasses) are now immutable. This means that you can't set or delete attributes anymore. Moreover, attributes that were formerly of type :obj:`list` are now of type :obj:`tuple`. Arguments: api_kwargs (Dict[:obj:`str`, any], optional): |toapikwargsarg| .. versionadded:: 20.0 Attributes: api_kwargs (:obj:`types.MappingProxyType` [:obj:`str`, any]): |toapikwargsattr| .. versionadded:: 20.0 )_bot_frozen _id_attrs api_kwargs_TelegramObject__INIT_PARAMSN"_TelegramObject__INIT_PARAMS_CHECK)r#r#returncVd|_d|_d|_t|xsi|_y)NF)r!r"r rr#)selfr#s S/var/www/cvtools/html/venv/lib/python3.12/site-packages/telegram/_telegramobject.py__init__zTelegramObject.__init__hs* # -/#' -=j>NB-OothercDt||jr{|js%td|jjdd|js%td|jjdd|j|jk(St ||S)aCompares this object with :paramref:`other` in terms of equality. If this object and :paramref:`other` are `not` objects of the same class, this comparison will fall back to Python's default implementation of :meth:`object.__eq__`. Otherwise, both objects may be compared in terms of equality, if the corresponding subclass of :class:`TelegramObject` has defined a set of attributes to compare and the objects are considered to be equal, if all of these attributes are equal. If the subclass has not defined a set of attributes to compare, a warning will be issued. Tip: If instances of a class in the :mod:`telegram` module are comparable in terms of equality, the documentation of the class will state the attributes that will be used for this comparison. Args: other (:obj:`object`): The object to compare with. Returns: :obj:`bool` Objects of type z0 can not be meaningfully tested for equivalence.) stacklevel) isinstance __class__r"r__name__super__eq__)r)r-r3s r*r6zTelegramObject.__eq__ss* eT^^ ,>>&t~~'>'>&?@$$  ??&u'?'?&@A((  >>U__4 4w~e$$r,cz|jr!t|j|jfSt|S)zBuilds a hash value for this object such that the hash of two objects is equal if and only if the objects are equal in terms of :meth:`__eq__`. Returns: :obj:`int` )r"hashr3r5__hash__)r)r3s r*r9zTelegramObject.__hash__s2 >>89 9w!!r,keyvaluec|ddk(s t|ddst| ||ytd|d|jj d) zOverrides :meth:`object.__setattr__` to prevent the overriding of attributes. Raises: :exc:`AttributeError` r_r!TN Attribute ` ` of class `z` can't be set!)getattrr5 __setattr__AttributeErrorr3r4)r)r:r;r3s r*rAzTelegramObject.__setattr__sW q6S=i > G U + #l4>>+B+B*C? S  r,c|ddk(s t|ddst| |ytd|d|jj d) zOverrides :meth:`object.__delattr__` to prevent the deletion of attributes. Raises: :exc:`AttributeError` rr=r!TNr>r?z` can't be deleted!)r@r5 __delattr__rBr3r4)r)r:r3s r*rDzTelegramObject.__delattr__sV q6S=i > G  $ #l4>>+B+B*CCV W  r,c2|jdd|jsjddnt|jd<dj fdt j D}|jjd|dS) aGives a string representation of this object in the form ``ClassName(attr_1=value_1, attr_2=value_2, ...)``, where attributes are omitted if they have the value :obj:`None` or are empty instances of :class:`collections.abc.Sized` (e.g. :class:`list`, :class:`dict`, :class:`set`, :class:`str`, etc.). As this class doesn't implement :meth:`object.__str__`, the default implementation will be used, which is equivalent to :meth:`__repr__`. Returns: :obj:`str` F) recursiveinclude_privater#Nz, c3K|]7}|0t|trt|dk(s |d|9yw)Nr=)r2rlen).0kas_dicts r* z*TelegramObject.__repr__..sP   &wqz51GAJ1, c71:. !  s=A()) _get_attrsr#popdictjoinsortedkeysr3r4)r)contentsrMs @r*__repr__zTelegramObject.__repr__s //E5/I KK d +%)$9GL !99  GLLN+   ..))*!H:Q77r,itemc|dk(rd} t||S#t$r,}td|jjd|d|d}~wwxYw)a Objects of this type are subscriptable with strings, where ``telegram_object["attribute_name"]`` is equivalent to ``telegram_object.attribute_name``. Tip: This is useful for dynamic attribute lookup, i.e. ``telegram_object[arg]`` where the value of ``arg`` is determined at runtime. In all other cases, it's recommended to use the dot notation instead, i.e. ``telegram_object.attribute_name``. .. versionchanged:: 20.0 ``telegram_object['from']`` will look up the key ``from_user``. This is to account for special cases like :attr:`Message.from_user` that deviate from the official Bot API. Args: item (:obj:`str`): The name of the attribute to look up. Returns: :obj:`object` Raises: :exc:`KeyError`: If the object does not have an attribute with the appropriate name. from from_userr/z! don't have an attribute called `z`.N)r@rBKeyErrorr3r4)r)rYexcs r* __getitem__zTelegramObject.__getitem__sg2 6>D 4& & "4>>#:#:";<6  s  A 'AA c`|jdddd}t|j|d<|S)an Overrides :meth:`object.__getstate__` to customize the pickling process of objects of this type. The returned state does `not` contain the :class:`telegram.Bot` instance set with :meth:`set_bot` (if any), as it can't be pickled. Returns: state (Dict[:obj:`str`, :obj:`object`]): The state of the object. TF)rGrF remove_botconvert_default_vaultr#)rQrSr#)r)outs r* __getstate__zTelegramObject.__getstate__ s;oo EdZ_  !1L r,statec H|jd|_tttt f|j di}|j dd}|jD]\}} t||||j|t!||_|r|j%yy#t$rftt|j|dtr& t|d||n'#t$r|||<YnwxYw|jdrY|||<YwxYw)a6 Overrides :meth:`object.__setstate__` to customize the unpickling process of objects of this type. Modifies the object in-place. If any data was stored in the :attr:`api_kwargs` of the pickled object, this method checks if the class now has dedicated attributes for those keys and moves the values from :attr:`api_kwargs` to the dedicated attributes. This can happen, if serialized data is loaded with a new version of this library, where the new version was updated to account for updates of the Telegram Bot API. If on the contrary an attribute was removed from the class, the value is not discarded but made available via :attr:`api_kwargs`. Args: state (:obj:`dict`): The data to set as attributes of this object. Nr#r!Fr=) _unfreezer rr strobjectrRitemssetattrrBr2r@r3property startswith_apply_api_kwargsrr#_freeze)r)rer#frozenr:vals r* __setstate__zTelegramObject.__setstate__s"  $sF{+UYY|R-HI 9e,  &HC &c3' &. z**:6  LLN 5" &gdnnc4@(K.#i5*.*- 3.^^C("% 3 &s<. B22.D!!C21D!2DD!DD!D! D!r)memodictc .|j}|jd|j}|j|}||t |<d|_|j dD]c}|dk(r |dk(r4t||ttt|j|B t||tt|||e|j r|j|j||j||S#t$rYwxYw)a@ Customizes how :func:`copy.deepcopy` processes objects of this type. The only difference to the default implementation is that the :class:`telegram.Bot` instance set via :meth:`set_bot` (if any) is not copied, but shared between the original and the copy, i.e.:: assert telegram_object.get_bot() is copy.deepcopy(telegram_object).get_bot() Args: memodict (:obj:`dict`): A dictionary that maps objects to their copies. Returns: :class:`telegram.TelegramObject`: The copied object. NFTrGr!r#)r set_botr3__new__idr!_get_attrs_namesrkrrrSr#r@rBro)r)rsbotclsresultrLs r* __deepcopy__zTelegramObject.__deepcopy__Xsii TnnS!#D&&t&< AI~L #3HT$//=RT\4]#^_ 8GD!,c#hN&&c1#--c2 $' (<(<(A(A(C$D!*-'#)rJ(*O"jjl [ UUZC3+<+<$<*cR [???C @s % CBCCc(|j||S)aConverts JSON data to a Telegram object. Args: data (Dict[:obj:`str`, ...]): The JSON data. bot (:class:`telegram.Bot`, optional): The bot associated with this object. Defaults to :obj:`None`, in which case shortcut methods will not be available. .. versionchanged:: 21.4 :paramref:`bot` is now optional and defaults to :obj:`None` Returns: The Telegram object. )r~rz)rr{r~rzs r*de_jsonzTelegramObject.de_jsons$||3|//r,.cD|sytdfd|DDS)aConverts a list of JSON objects to a tuple of Telegram objects. .. versionchanged:: 20.0 * Returns a tuple instead of a list. * Filters out any :obj:`None` values. Args: data (List[Dict[:obj:`str`, ...]]): The JSON data. bot (:class:`telegram.Bot`, optional): The bot associated with these object. Defaults to :obj:`None`, in which case shortcut methods will not be available. .. versionchanged:: 21.4 :paramref:`bot` is now optional and defaults to :obj:`None` Returns: A tuple of Telegram objects. r(c3&K|] }|| ywNr()rKrs r*rNz)TelegramObject.de_list..s[S3?S[sc3BK|]}j|ywr)r)rKdrzr{s r*rNz)TelegramObject.de_list..s$GQS[[C%8$Gs)tuplers` `r*de_listzTelegramObject.de_lists".[$G$$G[[[r,c#TK|j||jyw)zContext manager to temporarily unfreeze the object. For internal use only. Note: with to._unfrozen() as other_to: assert to is other_to N)rgror)s r* _unfrozenzTelegramObject._unfrozens    s&(cd|_y)NTr!rs r*rozTelegramObject._freezes  r,cd|_y)NFrrs r*rgzTelegramObject._unfreezes  r,c zt|jD]}tt|j|dt rBt jt5t|d||j|dddjt||dxt|||j|y#1swYxYw)abLoops through the api kwargs and for every key that exists as attribute of the object (and is None), it moves the value from `api_kwargs` to the attribute. *Edits `api_kwargs` in place!* This method is currently only called in the unpickling process, i.e. not on "normal" init. This is because * automating this is tricky to get right: It should be called at the *end* of the __init__, preferably only once at the end of the __init__ of the last child class. This could be done via __init_subclass__, but it's hard to not destroy the signature of __init__ in the process. * calling it manually in every __init__ is tedious * There probably is no use case for it anyway. If you manually initialize a TO subclass, then you can pass everything as proper argument. Nr=T) listrVr2r@r3rl contextlibsuppressrBrkrR)r)r#r:s r*rnz TelegramObject._apply_api_kwargss  )* 8C'$..#t>##67 8BBs  B11B: rGcd|jjddD}t|dr$t||jj n|}|r|Sd|DS)ay Returns the names of the attributes of this object. This is used to determine which attributes should be serialized when pickling the object. Args: include_private (:obj:`bool`): Whether to include private attributes. Returns: Iterator[:obj:`str`]: An iterator over the names of the attributes of this object. c3BK|]}|jD]}|ywr) __slots__)rKcss r*rNz2TelegramObject._get_attrs_names..s Q1Q[[QQQQQsN__dict__c3DK|]}|jdr|yw)r=N)rm)rKattrs r*rNz2TelegramObject._get_attrs_names..#sG$//#2FGs  )r3__mro__hasattrrrrV)r)rG all_slots all_attrss r*ryzTelegramObject._get_attrs_names s`R 6 6s ;Q 7>dJ6OE)T]]//1 2U^   GGGr,rFrarbcvi}|j|D]e}|r tjt||dn t||d}|*|r"t |dr|j d||<X|||<^|ra|||<g|r&|j dr|jdd|d<|r|jdd|S) aThis method is used for obtaining the attributes of the object. Args: include_private (:obj:`bool`): Whether the result should include private variables. recursive (:obj:`bool`): If :obj:`True`, will convert any ``TelegramObjects`` (if found) in the attributes to a dictionary. Else, preserves it as an object itself. remove_bot (:obj:`bool`): Whether the bot should be included in the result. convert_default_vault (:obj:`bool`): Whether :class:`telegram.DefaultValue` should be converted to its true value. This is necessary when converting to a dictionary for end users since DefaultValue is used in some classes that work with `tg.ext.defaults` (like `LinkPreviewOptions`) Returns: :obj:`dict`: A dict where the keys are attribute names and values are their values. ruNto_dictTrFr\r[r )ryr get_valuer@rrgetrR)r)rGrFrarbr~r:r;s r*rQzTelegramObject._get_attrs%s,(((I "C)&&wtS$'?@T3-    !: %  =DI %DI!S  " +.88K6DL  HHVT " r,cHtj|jS)zGives a JSON representation of object. .. versionchanged:: 20.0 Now includes all entries of :attr:`api_kwargs`. Returns: :obj:`str` )jsondumpsrrs r*to_jsonzTelegramObject.to_jsonRszz$,,.))r,c |j|}t}|jD]\}}t|tt fr|s|j |0g}|D]}t|dr"|j|j|1t|tt fr>|j|Dcgc]"}t|dr|j|n|$c}|j||||<t|tjst|||<|D]}|j||j|jdi|Scc}w)a:Gives representation of object as :obj:`dict`. .. versionchanged:: 20.0 * Now includes all entries of :attr:`api_kwargs`. * Attributes whose values are empty sequences are no longer included. Args: recursive (:obj:`bool`, optional): If :obj:`True`, will convert any TelegramObjects (if found) in the attributes to a dictionary. Else, preserves it as an object itself. Defaults to :obj:`True`. .. versionadded:: 20.0 Returns: :obj:`dict` rrr#)rQrrjr2rraddrappendrdatetimerrRupdate) r)rFrcpop_keysr:r;rqrYis r*rzTelegramObject.to_dict]sO$oo o2 !U))+ /JC%%/LL%! )DtY/ 4<<)<#DE#D5$-8 *.$%CJ!YBW I >]^ ^ 4( )CE8#4#45'.C1 /4 C GGCL  377<,- #s7'E% cH|j td|jS)zReturns the :class:`telegram.Bot` instance associated with this object. .. seealso:: :meth:`set_bot` .. versionadded: 20.0 Raises: RuntimeError: If no :class:`telegram.Bot` instance was set for this object. zDThis object has no bot associated with it. Shortcuts cannot be used.)r RuntimeErrorrs r*get_botzTelegramObject.get_bots* 99 V yyr,c||_y)zSets the :class:`telegram.Bot` instance associated with this object. .. seealso:: :meth:`get_bot` .. versionadded: 20.0 Arguments: bot (:class:`telegram.Bot` | :obj:`None`): The bot instance. N)r )r)rzs r*rvzTelegramObject.set_bots  r,r)r&N)FFFT)T)r&r)4r4 __module__ __qualname____doc__rrr$r rrh__annotations__r%rrrr+riboolr6intr9rArDrXr_r rrdrrrr} staticmethodr classmethodrrr rrrr rrorgrnryrQrrrrv __classcell__)r3s@r*rr9sG"H?I),M8CH%-=A$'7"89@;? Phx&8 PD P#%F#%t#%J "# "  s  6  d    s  t  $8#$8L!!!Fd3c6k(:#:;$:$sF{"3::x070d3;.?0G0d5(8,5(1C55 *.  ']x e_X&  '  >MQ0 ']0"*8"40;CE?0 ' 00&SW\ ']\"*4>":\AI%\ w| \\6  HW$5  8H882HH#H4!& &* +++ + $ + c5f%% & +Z * *777r 8E? t r,))rrrrrcollections.abcrrrr itertoolsrtypesrtypingrr r r r r rrrrrrrrtelegram._utils.datetimertelegram._utils.defaultvaluertelegram._utils.typesrtelegram._utils.warningsrtelegramrrrr(r,r*rsh&' !%""25*) )#3t Dw w r,