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