U hw@s:ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m ZddlmZddlmZddlmZmZmZmZddlmZmZmZddlmZmZdd lm Z dd l!m"Z"m#Z$m%Z%m&Z&m'Z'm(Z(dZ)d Z*d Z+d Z,ej-rddl.m/Z/e0eZ1dZ2GdddZ3Gdddej4Z5dS)N)versionhelpers__name__)rsa)markdown) MTProtoSender ConnectionConnectionTcpFull TcpMTProxy)Session SQLiteSession MemorySession) functionstypes)LAYER) MessageBox EntityCache SessionState ChannelStateEntity EntityTypez149.154.167.51z2001:67c:4e8:f002::ai)TelegramClient<c@s<eZdZddZddZddZddZd d Zd d Zd S) _ExportStatecCsd|_d|_d|_dS)NrF)_n_zero_ts _connectedselfr!F/tmp/pip-unpacked-wheel-c81u5j2r/telethon/client/telegrambaseclient.py__init__%sz_ExportState.__init__cCs|jd7_d|_dS)NrT)rrrr!r!r" add_borrow,sz_ExportState.add_borrowcCs8|jd8_|jdks td|jdkr4t|_dS)Nrrz)returned sender more than it was borrowed)rAssertionErrortimerrr!r!r" add_return0s z_ExportState.add_returncCs"|jdko |jo t|jtkS)Nr)rrr&r_DISCONNECT_EXPORTED_AFTERrr!r!r"should_disconnect6s  z_ExportState.should_disconnectcCs|j SN)rrr!r!r" need_connect;sz_ExportState.need_connectcCs|stdd|_dS)Nz+marked as disconnected when it was borrowedF)r)r%rrr!r!r"mark_disconnected>sz_ExportState.mark_disconnectedN) r __module__ __qualname__r#r$r'r)r+r,r!r!r!r"r$s rc@seZdZdZejZdZdZeddddddddddddddd d ddddd d d d e e de e j eefe j e efe e e e e e e e e e e e e eje j e ejfe e e dddZed ejdddZed ejdddZeddZejddZd ddddZd e dddZd ddd Zd e j eefd!d"d#Zd dd$d%Zd dd&d'Z d dd(d)Z!d dd*d+Z"d dd,d-Z#d@d dd.d/Z$d dd0d1Z%d dd2d3Z&d dd4d5Z'd dd6d7Z(d dd8d9Z)e*j+dAd dd:d;Z,e*j+d ddd?Z.dS)BTelegramBaseClienta. This is the abstract base class for the client. It defines some basic stuff like connecting, switching data center, etc, and leaves the `__call__` unimplemented. Arguments session (`str` | `telethon.sessions.abstract.Session`, `None`): The file name of the session file to be used if a string is given (it may be a full path), or the Session instance to be used otherwise. If it's `None`, the session will not be saved, and you should call :meth:`.log_out()` when you're done. Note that if you pass a string it will be a file in the current working directory, although you can also pass absolute paths. The session file contains enough information for you to login without re-sending the code, so if you have to enter the code more than once, maybe you're changing the working directory, renaming or removing the file, or using random names. api_id (`int` | `str`): The API ID you obtained from https://my.telegram.org. api_hash (`str`): The API hash you obtained from https://my.telegram.org. connection (`telethon.network.connection.common.Connection`, optional): The connection instance to be used when creating a new connection to the servers. It **must** be a type. Defaults to `telethon.network.connection.tcpfull.ConnectionTcpFull`. use_ipv6 (`bool`, optional): Whether to connect to the servers through IPv6 or not. By default this is `False` as IPv6 support is not too widespread yet. proxy (`tuple` | `list` | `dict`, optional): An iterable consisting of the proxy info. If `connection` is one of `MTProxy`, then it should contain MTProxy credentials: ``('hostname', port, 'secret')``. Otherwise, it's meant to store function parameters for PySocks, like ``(type, 'hostname', port)``. See https://github.com/Anorov/PySocks#usage-1 for more. local_addr (`str` | `tuple`, optional): Local host address (and port, optionally) used to bind the socket to locally. You only need to use this if you have multiple network cards and want to use a specific one. timeout (`int` | `float`, optional): The timeout in seconds to be used when connecting. This is **not** the timeout to be used when ``await``'ing for invoked requests, and you should use ``asyncio.wait`` or ``asyncio.wait_for`` for that. request_retries (`int` | `None`, optional): How many times a request should be retried. Request are retried when Telegram is having internal issues (due to either ``errors.ServerError`` or ``errors.RpcCallFailError``), when there is a ``errors.FloodWaitError`` less than `flood_sleep_threshold`, or when there's a migrate error. May take a negative or `None` value for infinite retries, but this is not recommended, since some requests can always trigger a call fail (such as searching for messages). connection_retries (`int` | `None`, optional): How many times the reconnection should retry, either on the initial connection or when Telegram disconnects us. May be set to a negative or `None` value for infinite retries, but this is not recommended, since the program can get stuck in an infinite loop. retry_delay (`int` | `float`, optional): The delay in seconds to sleep between automatic reconnections. auto_reconnect (`bool`, optional): Whether reconnection should be retried `connection_retries` times automatically if Telegram disconnects us or not. sequential_updates (`bool`, optional): By default every incoming update will create a new task, so you can handle several updates in parallel. Some scripts need the order in which updates are processed to be sequential, and this setting allows them to do so. If set to `True`, incoming updates will be put in a queue and processed sequentially. This means your event handlers should *not* perform long-running operations since new updates are put inside of an unbounded queue. flood_sleep_threshold (`int` | `float`, optional): The threshold below which the library should automatically sleep on flood wait and slow mode wait errors (inclusive). For instance, if a ``FloodWaitError`` for 17s occurs and `flood_sleep_threshold` is 20s, the library will ``sleep`` automatically. If the error was for 21s, it would ``raise FloodWaitError`` instead. Values larger than a day (like ``float('inf')``) will be changed to a day. raise_last_call_error (`bool`, optional): When API calls fail in a way that causes Telethon to retry automatically, should the RPC error of the last attempt be raised instead of a generic ValueError. This is mostly useful for detecting when Telegram has internal issues. device_model (`str`, optional): "Device model" to be sent when creating the initial connection. Defaults to 'PC (n)bit' derived from ``platform.uname().machine``, or its direct value if unknown. system_version (`str`, optional): "System version" to be sent when creating the initial connection. Defaults to ``platform.uname().release`` stripped of everything ahead of -. app_version (`str`, optional): "App version" to be sent when creating the initial connection. Defaults to `telethon.version.__version__`. lang_code (`str`, optional): "Language code" to be sent when creating the initial connection. Defaults to ``'en'``. system_lang_code (`str`, optional): "System lang code" to be sent when creating the initial connection. Defaults to `lang_code`. loop (`asyncio.AbstractEventLoop`, optional): Asyncio event loop to use. Defaults to `asyncio.get_running_loop()`. This argument is ignored. base_logger (`str` | `logging.Logger`, optional): Base logger name or instance to use. If a `str` is given, it'll be passed to `logging.getLogger()`. If a `logging.Logger` is given, it'll be used directly. If something else or nothing is given, the default logger will be used. receive_updates (`bool`, optional): Whether the client will receive updates or not. By default, updates will be received from Telegram as they occur. Turning this off means that Telegram will not send updates at all so event handlers, conversations, and QR login will not work. However, certain scripts don't need updates, so this will reduce the amount of bandwidth used. entity_cache_limit (`int`, optional): How many users, chats and channels to keep in the in-memory cache at most. This limit is checked against when processing updates. When this limit is reached or exceeded, all entities that are not required for update handling will be flushed to the session file. Note that this implies that there is a lower bound to the amount of entities that must be kept in memory. Setting this limit too low will cause the library to attempt to flush entities to the session file even if no entities can be removed from the in-memory cache, which will degrade performance. NF rTreni) connectionuse_ipv6proxy local_addrtimeoutrequest_retriesconnection_retries retry_delayauto_reconnectsequential_updatesflood_sleep_thresholdraise_last_call_error device_modelsystem_version app_version lang_codesystem_lang_codeloop base_loggerreceive_updatescatch_upentity_cache_limitrz(typing.Union[str, pathlib.Path, Session]ztyping.Type[Connection])r sessionapi_idapi_hashr3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHc sf|r|std||_ttr,tnttjsi|_?i|_@tAB|_Ci|_Dd|_Ed|_Fd|_Gd|_HtII|_J| |_K| |_LtM|_Nd|_Og|_PtQRtM|_Si|_TtU|_Vi|_Wd|_Xd|_Yi|_Z||_[tA\|_]t^|j d|__t`|_a||_btc|jjd|j |j'|j(|j,|j+|je|j]|jfd |_gdS)Nz\Your API ID or Hash cannot be empty or None. Refer to telethon.rtfd.io for more information.cseZdZfddZdS)z-TelegramBaseClient.__init__.._Loggerscs&|dr|jdddd}|S)Nz telethon..r)maxsplit) startswithsplitgetChild)r keyrEr!r" __missing__s z9TelegramBaseClient.__init__.._Loggers.__missing__N)rr-r.rSr!rRr!r"_LoggerssrTrzThe sqlite3 module is not available under this Python installation and no custom session instance was given; using MemorySession. You will need to re-login every time unless you use another session storagez6The given session must be a str or a Session instance.:Z sock_connectzEvent loop of type {} lacks `sock_connect`, which is needed to use proxies. Change the event loop in use to use proxies: # https://github.com/LonamiWebs/Telethon/issues/1337 import asyncio asyncio.set_event_loop(asyncio.SelectorEventLoop())Fzr?r@rArBrCrDrErFrGrHrTrn init_proxysystemZdefault_device_modelZdefault_system_versionr!rRr"r#s                   zTelegramBaseClient.__init__)r returncCstS)a Property with the ``asyncio`` event loop used by this client. Example .. code-block:: python # Download media in the background task = client.loop.create_task(message.download_media()) # Do some work ... # Join the task (wait for it to complete) await task )rget_running_looprr!r!r"rDszTelegramBaseClient.loopcCs|jjS)aK Property with a ``Future`` that resolves upon disconnection. Example .. code-block:: python # Wait for a disconnection to occur try: await client.disconnected except OSError: print('Error on disconnect') )r disconnectedrr!r!r"rszTelegramBaseClient.disconnectedcCs|jSr*)_flood_sleep_thresholdrr!r!r"r=sz(TelegramBaseClient.flood_sleep_thresholdcCst|pdd|_dS)NriQ)minr)r valuer!r!r"r=sc sZ|jdkrtd|jdkr(t|_n|jtkr>td|j|j|jj |jj |jj |j |j |jdIdHsxdS|jj|j_|jz0|jdj}|j|}|j|d|jWntk rYnX|jrtdddddddd}g}|jD]N\}}|dkr:tddd|j|jt|j|jd}n|t||jq|j !|||D]^}z|j|j"}Wn*tk r|j t#$d|j"YnX|j%t&t'j(|j"|jqbt)j*+|j,_-|j,}|j.rt)/|}|j0t)1t2|IdH|j 3r2|4IdH} | r2|5| IdH|j67|8|_9|j67|:|_;dS)a Connects to Telegram. .. note:: Connect means connect and nothing else, and only one low-level request is made to notify Telegram about which layer we will be using. Before Telegram sends you updates, you need to make a high-level request, like `client.get_me() `, as described in https://core.telegram.org/api/updates. Example .. code-block:: python try: await client.connect() except OSError: print('Failed to connect') Nz:TelegramClient instance cannot be reused after logging outzQThe asyncio event loop must not change after connection (see the FAQ for details)r]r5r6rFz9No access_hash in cache for channel %s, will not catch up)sz@TelegramBaseClient._save_states_and_entities..r unread_count)r)rZget_all_entitiesrIZprocess_entitiesrZcontactsZ ResolvedPeerrZ InputPeerUserrZ session_stateZset_update_stateZupdatesStatedatetimenowitems)r entitiesrrrrrr!r!r"_save_states_and_entitiess "&  z,TelegramBaseClient._save_states_and_entitiesc s|jdkrdS|IdH|j4IdH8|jD]\}}|IdHd|_q6|jW5QIdHRX|jr|jD] }| qzt |jIdH|j| |j dS)NF)rI _disconnectrrvaluesrrclearrcancelrwaitrclose)r rrZtaskr!r!r"rs    z#TelegramBaseClient._disconnect_corocs4|jIdHtj|jt|j|jdIdHdS)a9 Disconnect only, without closing the session. Used in reconnections to different data centers, where we don't want to close the session file; user disconnects however should close it since it means that their job with the client is complete and we should clean it up all. N)Zupdates_handleZkeepalive_handle)rrrZ_cancelrjrrrrr!r!r"rs  zTelegramBaseClient._disconnectcsp|jtd|||IdH}|j|j|j|jd|j j _ d|j_ |j | IdH|IdHS)zU Permanently switches the current connection to the new data center. z"Reconnecting to new data center %sN)rjrinfo_get_dcrIrrid ip_addressrrrrQrwrr)r Znew_dcdcr!r!r" _switch_dcs  zTelegramBaseClient._switch_dccCs||j_|jdS)z Callback from the sender whenever it needed to generate a new authorization key. This means we are not authorized. N)rIrrw)r rr!r!r"rsz%TelegramBaseClient._auth_key_callbackc sj}|js"tjIdH|_rjjsjtjIdH|_|jjD]}|jkrJt j |j ddqJz t fdd|jj DWStk rjtdjz"t fdd|jj DWYStk rtdd d YnXYnXdS) z/Gets the Data Center (DC) associated to 'dc_id'NF)oldc3s:|]2}|jkrt|jjkrt|jkr|VqdSr*)rboolZipv6rbcdnrrrrr r!r" s  z-TelegramBaseClient._get_dc..zOFailed to get DC %s (cdn = %s) with use_ipv6 = %s; retrying ignoring IPv6 checkc3s*|]"}|jkrt|jkr|VqdSr*)rrrr)rrr!r"r%s zFailed to get DC z (cdn = ))r|_configrrr _cdn_configZGetCdnConfigRequestZ public_keysrrZadd_keyZ public_keynextZ dc_options StopIterationrjrrrbra)r rrclspkr!rr"r s2     zTelegramBaseClient._get_dcc s||IdH}td|jd}||j|j|j|j|j|j|j dIdH|jt  d||t j |IdH}t j j|j|jd|j_t t|j}||IdH|S)z Creates a new exported `MTProtoSender` for the given `dc_id` and returns it. This method should be used by `_borrow_exported_sender`. N)r]rz,Exporting auth for new borrowed sender in %s)rbytes)rrrjrrrrrr}r~rrrauthZExportAuthorizationRequestZImportAuthorizationRequestrrr\rrr)r rrrrrr!r!r"_create_exported_sender,s z*TelegramBaseClient._create_exported_senderc s|j4IdH|jtd||j|d\}}|dkrht}||IdH}||_||f|j|<nF| r| |IdH}| |j |j |j|j|j|j|jdIdH||W5QIdHRSQIdHRXdS)a' Borrows a connected `MTProtoSender` for the given `dc_id`. If it's not cached, creates a new one if it doesn't exist yet, and imports a freshly exported authorization key for it to be usable. Once its job is over it should be `_return_exported_sender`. NzBorrowing sender for dc_id %d)NNr)rrjrdebugrgetrrrr+rrrrrrr}r~r$)r rrrrr!r!r"_borrow_exported_senderHs( z*TelegramBaseClient._borrow_exported_senderc sP|j4IdH2|jtd|j|j|j\}}|W5QIdHRXdS)z Returns a borrowed exported sender. If all borrows have been returned, the sender is cleanly disconnected. Nz&Returning borrowed sender for dc_id %d)rrjrrrrr')r rr_r!r!r"_return_exported_senderhsz*TelegramBaseClient._return_exported_senderc sl|j4IdHN|jD]<\}\}}|r|jtd||IdH|qW5QIdHRXdS)zN Cleans-up all unused exported senders by disconnecting them. Nz'Disconnecting borrowed sender for DC %d) rrrr)rjrrrr,)r rrrr!r!r"_clean_exported_sendersrs z*TelegramBaseClient._clean_exported_sendersc s|j|j}|sR|j|jddIdH}|j}||j|j|j ||j|j<|j t  d|j ||j|j|j|j|jd}|jj|_|j|j|j|j |j|j |j|jdIdH|S)z1Similar to ._borrow_exported_client, but for CDNsT)rNzCreating new CDN client)r5r7rDr)rrrrrIclonerrrrrrjrrr|rJrKr}rrDrrrrrqr~)r Z cdn_redirectrIrclientr!r!r"_get_cdn_clients2    z"TelegramBaseClient._get_cdn_clientcCstdS)a Invokes (sends) one or more MTProtoRequests and returns (receives) their result. Args: request (`TLObject` | `list`): The request or requests to be invoked. ordered (`bool`, optional): Whether the requests (if more than one was given) should be executed sequentially on the server. They run in arbitrary order by default. flood_sleep_threshold (`int` | `None`, optional): The flood sleep threshold to use for this request. This overrides the default value stored in `client.flood_sleep_threshold ` Returns: The result of the request (often a `TLObject`) or a list of results if more than one request was given. NNotImplementedError)r requestZorderedr!r!r"__call__szTelegramBaseClient.__call__cCstdSr*rrr!r!r"rszTelegramBaseClient._update_loopcstdSr*rrr!r!r"rsz)TelegramBaseClient._handle_auto_reconnect)F)F)/rr-r.__doc__rrrrr rxrdrtypingUniontuplerirZAbstractEventLooprergr#propertyrDZFuturerr=setterrrrrrrrrrrrrrrrabcabstractmethodrrrr!r!r!r"r/Ds!    k  Y%"     r/)6rrrrrerr&rrrkrZrrrZ __base_name__Zcryptor extensionsrnetworkrr r r sessionsr r rtlrrZtl.alltlobjectsrZ_updatesrrrrrrrrsrurtrv TYPE_CHECKINGZtelegramclientrrfrhr(rABCr/r!r!r!r"s6