def connect(self, reconnect=False): try: if not self.session.auth_key or (reconnect and self.sender is not None): self.session.auth_key, self.session.time_offset = \ authenticator.do_authentication(self.transport) self.session.save() self.sender = MtProtoSender(self.transport, self.session) query = InitConnectionRequest(api_id=self.api_id, device_model=platform.node(), system_version=platform.system(), app_version=self.__version__, lang_code="en", query=GetConfigRequest()) result = self.invoke( InvokeWithLayerRequest(layer=layer, query=query)) self.dc_options = result.dc_options self.sender.ack_requests_confirm = True self.signed_in = self.is_user_authorized() return True except RPCError as error: print(f"Could not stabilise initial connection: {error}.") return False
async def get_langpack(client: TelegramClient, lang_code: str, platform_name: str, from_version: int = 0) -> int: """ Gets langpack diff of full langpack if "from_version" set to 0 :param client: TelegramClient instance :param lang_code: custom language identifier, e.g. "english", "mycustompack" :param platform_name: platform name, e.g. "android", "ios" :param from_version: Lower version to diff with :return: langpack difference """ init_connection_request = InitConnectionRequest( api_id=client.api_id, lang_pack=platform_name, lang_code=lang_code, system_lang_code="ru", query=GetDifferenceRequest(from_version=from_version, lang_code=lang_code, lang_pack=platform_name), **{ x: 'whatever' for x in ['device_model', 'system_version', 'app_version'] }) lang_pack_difference = await client( InvokeWithLayerRequest(layer=config.current_layer, query=init_connection_request)) return lang_pack_difference
def get_lang_pack(client, lang_pack, lang_code='en', from_version=None): if from_version is not None: query = langpack.GetDifference(from_version=from_version) else: query = langpack.GetLangPackRequest(lang_code=lang_code) init_connection_request = InitConnectionRequest( api_id=client.api_id, lang_pack=lang_pack, query=query, lang_code=lang_code, **{x: 'shitfuck' for x in ['device_model', 'system_version', 'app_version', 'system_lang_code']} ) return client(InvokeWithLayerRequest(layer=all_tlobjects.LAYER, query=init_connection_request))
async def _create_sender(self) -> MTProtoSender: dc = await self.client._get_dc(self.dc_id) sender = MTProtoSender(self.auth_key, loggers=self.client._log) await sender.connect(self.client._connection(dc.ip_address, dc.port, dc.id, loggers=self.client._log, proxy=self.client._proxy)) if not self.auth_key: log.debug(f"Exporting auth to DC {self.dc_id}") auth = await self.client(ExportAuthorizationRequest(self.dc_id)) self.client._init_request.query = ImportAuthorizationRequest( id=auth.id, bytes=auth.bytes) await sender.send(InvokeWithLayerRequest(LAYER, self.client._init_request)) self.auth_key = sender.auth_key return sender
def connect(self, reconnect=False): """Connects to the Telegram servers, executing authentication if required. Note that authenticating to the Telegram servers is not the same as authenticating the app, which requires to send a code first.""" if self.transport is None: self.transport = TcpTransport(self.session.server_address, self.session.port, proxy=self.proxy) try: if not self.session.auth_key or (reconnect and self.sender is not None): self.session.auth_key, self.session.time_offset = \ authenticator.do_authentication(self.transport) self.session.save() self.sender = MtProtoSender(self.transport, self.session) # Now it's time to send an InitConnectionRequest # This must always be invoked with the layer we'll be using query = InitConnectionRequest(api_id=self.api_id, device_model=platform.node(), system_version=platform.system(), app_version=self.__version__, lang_code='en', query=GetConfigRequest()) result = self.invoke( InvokeWithLayerRequest(layer=layer, query=query)) # We're only interested in the DC options, # although many other options are available! self.dc_options = result.dc_options # We're signed in if we're authorized self.signed_in = self.is_user_authorized() return True except RPCError as error: print('Could not stabilise initial connection: {}'.format(error)) return False
def connect(self, reconnect=False, device_model=None, system_version=None, app_version=None, lang_code=None): """Connects to the Telegram servers, executing authentication if required. Note that authenticating to the Telegram servers is not the same as authenticating the desired user itself, which may require a call (or several) to 'sign_in' for the first time. Default values for the optional parameters if left as None are: device_model = platform.node() system_version = platform.system() app_version = TelegramClient.__version__ lang_code = 'en' """ if self.transport is None: self.transport = TcpTransport(self.session.server_address, self.session.port, proxy=self.proxy) try: if not self.session.auth_key or (reconnect and self.sender is not None): self.session.auth_key, self.session.time_offset = \ authenticator.do_authentication(self.transport) self.session.save() self.sender = MtProtoSender(self.transport, self.session) self.sender.connect() # Set the default parameters if left unspecified if not device_model: device_model = platform.node() if not system_version: system_version = platform.system() if not app_version: app_version = self.__version__ if not lang_code: lang_code = 'en' # Now it's time to send an InitConnectionRequest # This must always be invoked with the layer we'll be using query = InitConnectionRequest( api_id=self.api_id, device_model=device_model, system_version=system_version, app_version=app_version, lang_code=lang_code, query=GetConfigRequest()) result = self.invoke( InvokeWithLayerRequest( layer=layer, query=query)) # We're only interested in the DC options, # although many other options are available! self.dc_options = result.dc_options self.login_success = True return True except (RPCError, ConnectionError) as error: # Probably errors from the previous session, ignore them self._logger.warning('Could not stabilise initial connection: {}' .format(error)) return False