This page lists all the available versions of the library, in chronological order. You should read this when upgrading the library to know where your code can break, and where it can take advantage of new goodies!
List of All Versions
- Changelog (Version History)
- Several bug fixes (v0.18.2)
- Iterator methods (v0.18.1)
- Sessions overhaul (v0.18)
- Further easing library usage (v0.17.4)
- New small convenience functions (v0.17.3)
- New small convenience functions (v0.17.2)
- Updates as Events (v0.17.1)
- Trust the Server with Updates (v0.17)
- MtProto 2.0 (v0.16.1)
- Sessions as sqlite databases (v0.16)
- IPv6 support (v0.15.5)
- General enhancements (v0.15.4)
- Bug fixes with updates (v0.15.3)
- Bug fixes and new small features (v0.15.2)
- Custom Entity Database (v0.15.1)
- Updates Overhaul Update (v0.15)
- Serialization bug fixes (v0.14.2)
- Farewell, BinaryWriter (v0.14.1)
- Several requests at once and upload compression (v0.14)
- Quick fix-up (v0.13.6)
- Attempts at more stability (v0.13.5)
- More bug fixes and enhancements (v0.13.4)
- Bug fixes and enhancements (v0.13.3)
- New way to work with updates (v0.13.2)
- Invoke other requests from within update callbacks (v0.13.1)
- Connection modes (v0.13)
- Added verification for CDN file (v0.12.2)
- CDN support (v0.12.1)
- Newbie friendly update (v0.12)
- get_input_* now works with vectors (v0.11.5)
- get_input_* everywhere (v0.11.4)
- Quick .send_message() fix (v0.11.3)
- Callable TelegramClient (v0.11.2)
- Improvements to the updates (v0.11.1)
- Support for parallel connections (v0.11)
- JSON session file (v0.10.1)
- Full support for different DCs and ++stable (v0.10)
- Stability improvements (v0.9.1)
- General improvements (v0.9)
- Bot login and proxy support (v0.8)
- Long-run bug fix (v0.7.1)
- Two factor authentication (v0.7)
- Updated pip version (v0.6)
- Ready, pip, go! (v0.5)
- Made InteractiveTelegramClient cool (v0.4)
- Media revolution and improvements to update handling! (v0.3)
- Handle updates in their own thread! (v0.2)
- First working alpha version! (v0.1)
Published at 2018/03/27
Just a few bug fixes before they become too many.
- Getting an entity by its positive ID should be enough, regardless of their
type (whether it’s an
Channel). Although wrapping them inside a
Peeris still recommended, it’s not necessary.
client.edit_2fafunction to change your Two Factor Authentication settings.
.stringify()and string representation for custom
- Some bug regarding
events.ChatActionwasn’t picking up all the pins.
force_document=Truewas being ignored for albums.
- Now you’re able to send
- Wrong access to a member on chat forbidden error for
.get_participants. An empty list is returned instead.
.get[_input]_entityhas been moved up so if someone has “me” or “self” as their name they won’t be retrieved.
Published at 2018/03/17
.get_ methods in the
TelegramClient now have a
counterpart, so you can do operations while retrieving items from them.
For instance, you can
break once you
find what you’re looking for instead fetching them all at once.
Another big thing, you can get entities by just their positive ID. This may cause some collisions (although it’s very unlikely), and you can (should) still be explicit about the type you want. However, it’s a lot more convenient and less confusing.
- The library only offers the default
SQLiteSessionagain. See Session Files for more on how to use a different storage from now on.
- Events now override
.stringify(), just like every other
delete()for the message that triggered it.
client.get_participants()counterpart) now expose the
filterargument, and the returned users also expose the
- You can now use
client.list_event_handlers()similar how you could with normal updates.
- New properties on
.gifto access only specific types of documents.
Draftclass now exposes
.raw_text, as well as a new
Draft.send()to send it.
- Fixes for
Event.delete_messageswhich wouldn’t handle
- Bot API style IDs not working on
- Less RPC are made when accessing the
.chatof some events (mostly those that occur in a channel).
- You can send albums larger than 10 items (they will be sliced for you), as well as mixing normal files with photos.
TLObjectnow have Python type hints.
Published at 2018/03/04
|Scheme layer used: 75|
Session’s have been revisited thanks to the work of @tulir and
they now use an ABC so you
can easily implement your own!
The default will still be a
SQLiteSession, but you might want to use
AlchemySessionContainer if you need. Refer to the section of
the documentation on Session Files for more.
events.MessageChangeddoesn’t exist anymore. Use the new
- The mentioned addition of new session types.
- You can omit the event type on
- You can
raise StopPropagationof events if you added several of them.
.get_participants()can now get up to 90,000 members from groups with 100,000 if when
aggressive=True, “bypassing” Telegram’s limit.
- You now can access
- Multiple captions are now supported when sending albums.
client.send_message()has an optional
file=parameter, so you can do
- You can now access the public
client.forward_messages, with its own wrapper on
- Silly bug regarding
client.send_voice_note()was missing some parameters.
client.send_file()plays better with streams now.
- Incoming messages from bots weren’t working with whitelists.
- Markdown’s URL regex was not accepting newlines.
- Better attempt at joining background update threads.
- Use the right peer type when a marked integer ID is provided.
events.Rawis now a no-op.
- Logging calls in the
TcpClientto spot errors.
eventsresolution is postponed until you are successfully connected, so you can attach them before starting the client.
- When an entity is not found, it is searched in all dialogs. This might not always be desirable but it’s more comfortable for legitimate uses.
- Some non-persisting properties from the
Sessionhave been moved out.
Published at 2018/02/24
Some new things and patches that already deserved their own release.
NewMessageto easily filter messages.
.get_participants()convenience method to get members from chats.
.send_message()now accepts a
- You can now
.get_entity()through exact name match instead username.
ProxyConnectionErrorinstead looping forever so you can
exceptit on your own code and behave accordingly.
.parse_usernamewould fail with
www.or a trailing slash.
events.MessageChangedwould fail with
- You can now send
b'byte strings'directly as files again.
.send_file()was not respecting the original captions when passing another message (or media) as the file.
- Downloading media from a different data center would always log a warning for the first time.
- You can use
.get_me(input_peer=True)if all you need is your self ID.
- New addition to the interactive client example to show peer information.
- Avoid special casing
NewMessageevents, so you can always safely rely on
.senderto get the right ID.
Published at 2018/02/18
More bug fixes and a few others addition to make events easier to use.
hachoirto extract video and audio metadata before upload.
bot_tokenwouldn’t work on
.start(), and changes to
password(now it will ask you for it if you don’t provide it, as docstring hinted).
.edit_message()was ignoring the formatting (e.g. markdown).
- Added missing case to the
NewMessageevent for normal groups.
- Accessing the
NewMessageevent was failing due to a bug with the markdown unparser.
Published at 2018/02/15
Primarily bug fixing and a few welcomed additions.
- New convenience
.edit_message()method on the
.delete()shorthands on the
- Default to markdown parsing when sending and editing messages.
- Support for inline mentions when sending and editing messages. They work
like inline urls (e.g.
[text](@username)) and also support the Bot-API style (see here).
- Periodically send
GetStateRequestautomatically to keep the server sending updates even if you’re not invoking any request yourself.
- HTML parsing was failing due to not handling surrogates properly.
.sign_upwas not accepting
- Whitelisting more than one chat on
- Video files are sent as a video by default unless
Published at 2018/02/09
Of course there was more work to be done regarding updates, and it’s here!
The library comes with a new
events module (which you will often import
from telethon import TelegramClient, events). This are pretty much
all the additions that come with this version change, but they are a nice
addition. Refer to Working with Updates to get started with events.
Published at 2018/02/03
The library trusts the server with updates again. The library will not
check for duplicates anymore, and when the server kicks us, it will run
GetStateRequest so the server starts sending updates again (something
it wouldn’t do unless you invoked something, it seems). But this update
also brings a few more changes!
__ne__, so you can compare them.
- Added some missing cases on
.get_input_entity()and peer functions.
obj.to_dict()now has a
'_'key with the type used.
.start()can also sign up now.
- More parameters for
- Updated list of RPC errors.
- HTML parsing thanks to @tulir! It can be used similar to markdown:
MessageMedia’s as the
- Some documentation updates and fixed to clarify certain things.
- New exact match feature on https://lonamiwebs.github.io/Telethon.
- Return as early as possible from
.get_input_entity()and similar, to avoid penalizing you for doing this right.
Published at 2018/01/19
TLObject’s (instances returned by the API and
now acquired a new
.resolve() method. While this should be used by the
library alone (when invoking a request), it means that you can now use
Peer types or even usernames where a
InputPeer is required. The
object now has access to the
client, so that it can fetch the right
type if needed, or access the session database. Furthermore, you can
reuse requests that need “autocast” (e.g. you put User but
was needed), since
.resolve() is called when invoking. Before, it was
only done on object construction.
.start()asks for your phone only if required.
- Better file cache. All files under 10MB, once uploaded, should never be needed to be re-uploaded again, as the sent media is cached to the session.
- The mentioned
.resolve()to perform “autocast”, more powerful.
- Upload and download methods are no longer part of
.stringify(). Only override
.on_response()if necessary (small amount of cases).
- Reduced “autocast” overhead as much as possible. You shouldn’t be penalized if you’ve provided the right type.
Published at 2018/01/11
|Scheme layer used: 74|
The library is now using MtProto 2.0! This shouldn’t really affect you as an end user, but at least it means the library will be ready by the time MtProto 1.0 is deprecated.
.start()method, to make the library avoid boilerplate code.
.send_fileaccepts a new optional
thumbnailparameter, and returns the
Messagewith the sent file.
- The library uses again only a single connection. Less updates are be dropped now, and the performance is even better than using temporary connections.
without rowidwill only be used on the
- Phone code hash is associated with phone, so you can change your mind
Published at 2017/12/28
In the beginning, session files used to be pickle. This proved to be bad
as soon as one wanted to add more fields. For this reason, they were
migrated to use JSON instead. But this proved to be bad as soon as one
wanted to save things like entities (usernames, their ID and hash), so
now it properly uses
which has been well tested, to save the session files! Calling
.get_input_entity using a
username no longer will need to fetch
it first, so it’s really 0 calls again. Calling
always fetch the most up to date version.
Furthermore, nearly everything has been documented, thus preparing the library for Read the Docs (although there are a few things missing I’d like to polish first), and the logging are now better placed.
.get_dialogs()now returns a single list instead a tuple consisting of a custom class that should make everything easier to work with.
.get_message_history()also returns a single list instead a tuple, with the
Messageinstances modified to make them more convenient.
Both lists have a
.total attribute so you can still know how many
dialogs/messages are in total.
- The mentioned use of
sqlite3for the session file.
.get_entity()now supports lists too, and it will make as little API calls as possible if you feed it
InputPeertypes. Usernames will always be resolved, since they may have changed.
.set_proxy()method, to avoid having to create a new
datetypes supported to represent a date parameter.
- Empty strings weren’t working when they were a flag parameter (e.g., setting no last name).
- Fix invalid assertion regarding flag parameters as well.
- Avoid joining the background thread on disconnect, as it would be
Nonedue to a race condition.
- Correctly handle
Nonedates when downloading media.
.download_profile_photowas failing for some channels.
datewas being serialized as local date, but that was wrong.
datewas being represented as a
floatinstead of an
.tlparser wasn’t stripping inline comments.
- Removed some redundant checks on
- Use a synchronized queue instead a hand crafted version.
- Use signed integers consistently (e.g.
- Always read the corresponding
TLObjectfrom API responses, except for some special cases still.
- A few more
exceptlow level to correctly wrap errors.
- More accurate exception types.
invokeWithLayer(initConnection(X))now wraps every first request after
As always, report if you have issues with some of the changes!
Published at 2017/11/16
|Scheme layer used: 73|
It’s here, it has come! The library now supports IPv6! Just pass
use_ipv6=True when creating a
TelegramClient. Note that I could
not test this feature because my machine doesn’t have IPv6 setup. If
you know IPv6 works in your machine but the library doesn’t, please
refer to #425.
- IPv6 support.
- New method to extract the text surrounded by
MessageEntity’s, in the
- Markdown parsing is Done Right.
- Reconnection on failed invoke. Should avoid “number of retries reached 0” (#270).
- Some missing autocast to
- The library uses the
loggingas it should have always done.
TcpClient.is_connected()is now more reliable.
Published at 2017/11/04
|Scheme layer used: 72|
This update brings a few general enhancements that are enough to deserve
a new release, with a new feature: beta markdown-like parsing for
parse_mode='md'for Markdown! It works in a similar fashion to the official clients (defaults to double underscore/asterisk, like
**this**). Please report any issues with emojies or enhancements for the parser!
.idle()method so your main thread can do useful job (listen for updates).
- Add missing
- The list of known peers could end “corrupted” and have users with
access_hash=None, resulting in
structerror for it not being an integer. You shouldn’t encounter this issue anymore.
- The warning for “added update handler but no workers set” wasn’t actually working.
.get_input_peerwas ignoring a case for
- There used to be an exception when logging exceptions (whoops) on update handlers.
- “Downloading contacts” would produce strange output if they had
;) in their name.
- Fix some cyclic imports and installing dependencies from the
- Code generation was using f-strings, which are only supported on Python ≥3.6.
auth_keygeneration has been moved from
.invoke(). There were some issues were
.connect()failed and the
Noneso this will ensure to have a valid
auth_keywhen needed, even if
- Support for higher limits on
- Much faster integer factorization when generating the required
auth_key. Thanks @delivrance for making me notice this, and for the pull request.
Published at 2017/10/20
Hopefully a very ungrateful bug has been removed. When you used to invoke some request through update handlers, it could potentially enter an infinite loop. This has been mitigated and it’s now safe to invoke things again! A lot of updates were being dropped (all those gzipped), and this has been fixed too.
More bug fixes include a correct
of certain TLObjects thanks to @stek29, and
that would cause the library to crash thanks to @andr-04, and the
ReadThread not re-starting if you were already authorized.
.to_bytes() function has been replaced with
__bytes__ so now you can do
Published at 2017/10/14
This release primarly focuses on a few bug fixes and enhancements. Although more stuff may have broken along the way.
- You will be warned if you call
- New customizable threshold value on the session to determine when to
automatically sleep on flood waits. See
.get_drafts()method with a custom
Draftclass by @JosXa.
- Join all threads when calling
.disconnect(), to assert no dangling thread is left alive.
- Larger chunk when downloading files should result in faster downloads.
- You can use a callable key for the
EntityDatabase, so it can be any filter you need.
.get_input_entitywas failing for IDs and other cases, also making more requests than it should.
abspathwhen sending a file. You can now also override the attributes.
.send_message()was failing with channels.
.get_dialogs(limit=None)should now return all the dialogs correctly.
- Temporary fix for abusive duplicated updates.
Published at 2017/10/05
The main feature of this release is that Telethon now has a custom
database for all the entities you encounter, instead depending on
@lru_cache on the
EntityDatabase will, by default, cache all the users, chats
and channels you find in memory for as long as the program is running.
The session will, by default, save all key-value pairs of the entity
identifiers and their hashes (since Telegram may send an ID that it
thinks you already know about, we need to save this information).
You can prevent the
EntityDatabase from saving users by setting
client.session.entities.enabled = False, and prevent the
from saving input entities at all by setting
client.session.save_entities = False. You can also clear the cache
for a certain user through
client.session.entities.clear_cache(entity=None), which will clear
all if no entity is given.
.sign_inaccepts phones as integers.
- Changing the IP to which you connect to is as simple as
client.session.server_address = 'ip', since now the server address is always queried from the session.
Published at 2017/10/01
After hundreds of lines changed on a major refactor, it’s finally here. It’s the Updates Overhaul Update; let’s get right into it!
.create_new_connection()is gone for good. No need to deal with this manually since new connections are now handled on demand by the library itself.
- You can invoke requests from update handlers. And any other thread. A new temporary will be made, so that you can be sending even several requests at the same time!
- Several worker threads for your updates! By default,
Nonewill spawn. I recommend you to work with
update_workers=4to get started, these will be polling constantly for updates.
- You can also change the number of workers at any given time.
- The library can now run in a single thread again, if you don’t
need to spawn any at all. Simply set
spawn_read_thread=Falsewhen creating the
- You can specify
.get_dialogs()to get all of them.
- Updates are expanded, so you don’t need to check if the update
.updatesor an inner
InputPeerentities are saved in the session file, but you can disable this by setting
.get_input_entitymethod, which makes use of the above feature. You should use this when a request needs a
InputPeer, rather than the whole entity (although both work).
- Assert that either all or None dependent-flag parameters are set before sending the request.
- Phone numbers can have dashes, spaces, or parenthesis. They’ll be removed before making the request.
- You can override the phone and its hash on
.sign_in(), if you’re creating a new
TelegramClienton two different places.
.log_out()was consuming all retries. It should work just fine now.
- The session would fail to load if the
auth_keyhad been removed manually.
Updates.check_errorwas popping wrong side, although it’s been completely removed.
ServerError’s will be ignored, and the request will immediately be retried.
- Cross-thread safety when saving the session file.
- Some things changed on a matter of when to reconnect, so please report any bugs!
TelegramClientis now only an abstraction over the
TelegramBareClient, which can only do basic things, such as invoking requests, working with files, etc. If you don’t need any of the abstractions the
TelegramClient, you can now use the
TelegramBareClientin a much more comfortable way.
MtProtoSenderis not thread-safe, but it doesn’t need to be since a new connection will be spawned when needed.
- New connections used to be cached and then reused. Now only their sessions are saved, as temporary connections are spawned only when needed.
- Added more RPC errors to the list.
: Broken due to a condition which should had been the opposite (sigh), fixed 4 commits ahead on https://github.com/LonamiWebs/Telethon/commit/62ea77cbeac7c42bfac85aa8766a1b5b35e3a76c.
That’s pretty much it, although there’s more work to be done to make the overall experience of working with updates even better. Stay tuned!
Published at 2017/09/29
- Important, related to the serialization. Every object or request
that had to serialize a
True/Falsetype was always being serialized as
- Another bug that didn’t allow you to leave as
Noneflag parameters that needed a list has been fixed.
Published at 2017/09/28
v0.14 had started working on the new
to dump the
BinaryWriter and its usage on the
serializing TLObjects, and this release finally removes it. The speed up
when serializing things to bytes should now be over twice as fast
wherever it’s needed.
- This version is again compatible with Python 3.x versions below 3.5 (there was a method call that was Python 3.5 and above).
Published at 2017/09/27
New major release, since I’ve decided that these two features are big enough:
- Requests larger than 512 bytes will be compressed through gzip, and if the result is smaller, this will be uploaded instead.
- You can now send multiple requests at once, they’re simply
.invoke(). Note that the server doesn’t guarantee the order in which they’ll be executed!
Internally, another important change. The
.on_send function on the
TLObjects is gone, and now there’s a new
my tests, this has always been over twice as fast serializing objects,
although more replacements need to be done, so please report any issues.
.get_input_mediahelper methods. Now you can even use another message as input media!
Published at 2017/09/23
Before getting any further, here’s a quick fix-up with things that
should have been on
v0.13.5 but were missed. Specifically, the
timeout when receiving a request will now work properly.
Some other additions are a tiny fix when handling updates, which was
ignoring some of them, nicer
TLObject’s, and not stopping the
ReadThread if you try
invoking something there (now it simply returns
Published at 2017/09/23
Yet another update to fix some bugs and increase the stability of the library, or, at least, that was the attempt!
This release should really improve the experience with the background thread that the library starts to read things from the network as soon as it can, but I can’t spot every use case, so please report any bug (and as always, minimal reproducible use cases will help a lot).
setup.pywas failing on Python < 3.5 due to some imports.
- Duplicated updates should now be ignored.
.send_messagewould crash in some cases, due to having a typo using the wrong object.
"socket is None"when calling
.connect()should not happen anymore.
BrokenPipeErrorwas still being raised due to an incorrect order on the
- Type hinting for all the generated
TLObjects! IDEs like PyCharm will benefit from this.
ProxyConnectionErrorshould properly be passed to the main thread for you to handle.
- The background thread will only be started after you’re authorized on Telegram (i.e. logged in), and several other attempts at polishing the experience with this thread.
Connectioninstance is only created once now, and reused later.
.connect()should have a better behavior now (like actually trying to connect even if we seemingly were connected already).
.reconnect()behavior has been changed to also be more consistent by making the assumption that we’ll only reconnect if the server has disconnected us, and is now private.
TLObject.__repr__doesn’t show the original TL definition anymore, it was a lot of clutter. If you have any complaints open an issue and we can discuss it.
- Internally, the
'+'from the phone number is now stripped, since it shouldn’t be included.
- Spotted a new place where
BrokenAuthKeyErrorwould be raised, and it now is raised there.
Published at 2017/09/18
TelegramClientnow exposes a
- Initial authorization on a new data center will retry up to 5 times by default.
- Errors that couldn’t be handled on the background thread will be
raised on the next call to
- Now you should be able to sign in even if you have
process_updates=Trueand no previous session.
- Some errors and methods are documented a bit clearer.
.send_message()could randomly fail, as the returned type was not expected.
TimeoutErroris now ignored, since the request will be retried up to 5 times by default.
- “-404” errors (
BrokenAuthKeyError’s) are now detected when first connecting to a new data center.
BufferErroris handled more gracefully, in the same way as
- Attempt at fixing some “NoneType has no attribute…” errors (with the
Published at 2017/09/14
- Reconnection used to fail because it tried invoking things from
- Inferring random ids for
- Downloading media from CDNs failed due to having forgotten to remove a single line.
TcpClient.close()now has a ``threading.Lock``, so
NoneType has no close()should not happen.
- New workaround for
msg seqno too low/high. Also, both
Session.id/seqare not saved anymore.
- Request will be retried up to 5 times by default rather than failing on the first attempt.
InvalidChecksumError’s are now ignored by the library.
TelegramClient.get_entity()is now public, and uses the
- New method to ``.send_voice_note()``’s.
- Methods to send message and media now support a ``reply_to`` parameter.
.send_message()now returns the full message which was just sent.
Published at 2017/09/08
This update brings a new way to work with updates, and it’s begging for your feedback, or better names or ways to do what you can do now.
Please refer to the wiki/Usage
an in-depth description on how to work with updates now. Notice that you
cannot invoke requests from within handlers anymore, only the
v.0.13.1 patch allowed you to do so.
- Periodic pings are back.
- The username regex mentioned on
UsernameInvalidErrorwas invalid, but it has now been fixed.
- Sending a message to a phone number was failing because the type used for a request had changed on layer 71.
- CDN downloads weren’t working properly, and now a few patches have been applied to ensure more reliability, although I couldn’t personally test this, so again, report any feedback.
Published at 2017/09/04
This update brings some big changes to the update system, so please read it if you work with them!
A silly “bug” which hadn’t been spotted has now been fixed. Now you can invoke other requests from within your update callbacks. However this is not advised. You should post these updates to some other thread, and let that thread do the job instead. Invoking a request from within a callback will mean that, while this request is being invoked, no other things will be read.
Internally, the generated code now resides under a lot less files, simply for the sake of avoiding so many unnecessary files. The generated code is not meant to be read by anyone, simply to do its job.
Unused attributes have been removed from the
TLObject class too, and
.sign_up() returns the user that just logged in in a similar way to
Published at 2017/09/04
|Scheme layer used: 71|
The purpose of this release is to denote a big change, now you can
connect to Telegram through different **connection
Also, a second thread will always be started when you connect a
TelegramClient, despite whether you’ll be handling updates or
ignoring them, whose sole purpose is to constantly read from the
The reason for this change is as simple as “reading and writing shouldn’t be related”. Even when you’re simply ignoring updates, this way, once you send a request you will only need to read the result for the request. Whatever Telegram sent before has already been read and outside the buffer.
- The mentioned different connection modes, and a new thread.
- You can modify the
Sessionattributes through the
RPCError’s now belong to some request you’ve made, which makes more sense.
None(default) parameters more gracefully (it used to crash).
- The low-level socket doesn’t use a handcrafted timeout anymore, which
should benefit by avoiding the arbitrary
sleep(0.1)that there used to be.
.sign_updoes not take a
phoneargument anymore. Change this or you will be using
code, and it will fail! The definition looks like
def sign_up(self, code, first_name, last_name='').
- The old
JsonSessionfinally replaces the original
Session(which used pickle). If you were overriding any of these, you should only worry about overriding
Published at 2017/08/28
Since the Content Distributed Network (CDN) is not handled by Telegram
itself, the owners may tamper these files. Telegram sends their sha256
sum for clients to implement this additional verification step, which
now the library has. If any CDN has altered the file you’re trying to
CdnFileTamperedError will be raised to let you know.
TLObject.stringify() was showing bytes as lists (now
fixed) and RPC errors are reported by default:
If you still would like to opt out, simply set
client.session.report_errors = False to disable this feature.
However Daniil would really thank you if you helped him (and everyone)
by keeping it on!
Published at 2017/08/24
The biggest news for this update are that downloading media from CDN’s (you’ll often encounter this when working with popular channels) now works.
- The method used to download documents crashed because two lines were swapped.
- Determining the right path when downloading any file was very weird, now it’s been enhanced.
.sign_in()method didn’t support integer values for the code! Now it does again.
Some important internal changes are that the old way to deal with RSA public keys now uses a different module instead the old strange hand-crafted version.
Hope the new, super simple
README.rst encourages people to use
Telethon and make it better with either suggestions, or pull request.
Pull requests are super appreciated, but showing some support by
leaving a star also feels nice ⭐️.
Published at 2017/08/22
|Scheme layer used: 70|
This update is overall an attempt to make Telethon a bit more user friendly, along with some other stability enhancements, although it brings quite a few changes.
.send_media_file()are now a single method called
.send_file(). It’s also important to note that the order of the parameters has been swapped: first to who you want to send it, then the file itself.
- The same applies to
.download_msg_media(), which has been renamed to
.download_media(). The method now supports a
Messageitself too, rather than only
Message.media. The specialized
.download_contact()still exist, but are private.
- Updated to layer 70!
- Both downloading and uploading now support stream-like objects.
- A lot faster initial connection if
sympyis installed (can be installed through
libsslwill also be used if available on your system (likely on Linux based systems). This speed boost should also apply to uploading and downloading files.
- You can use a phone number or an username for methods like
.send_file(), and all the other quick-access methods provided by the
- Crashing when migrating to a new layer and receiving old updates should not happen now.
InputPeerChannelis now casted to
.get_new_msg_id()should now be thread-safe. No promises.
- Logging out on macOS caused a crash, which should be gone now.
- More checks to ensure that the connection is flagged correctly as either connected or not.
Downloading files from CDN’s will not work yet (something new that comes with layer 70).
That’s it, any new idea or suggestion about how to make the project even more friendly is highly appreciated.
Did you know that you can pretty print any result Telegram returns
TLObject’s) by using their
Great for debugging!
Published at 2017/07/11
Quick fix-up of a bug which hadn’t been encountered until now. Auto-cast
get_input_* now works.
Published at 2017/07/10
Besides this, every Telegram object now features a new default
.__str__ look, and also a .stringify()
to pretty format them, if you ever need to inspect them.
The library now uses the DEBUG level everywhere, so no more warnings or information messages if you had logging enabled.
no_webpage parameter from
.send_message has been
link_preview for clarity, so now it does the opposite (but has a
Published at 2017/07/05
A very quick follow-up release to fix a tiny bug with
.send_message(), no new features.
Published at 2017/07/04
|Scheme layer used: 68|
There is a new preferred way to invoke requests, which you’re encouraged to use:
# New! result = client(SomeRequest()) # Old. result = client.invoke(SomeRequest())
Existing code will continue working, since the old
.invoke() has not
.create_new_connection(), it will also handle
FileMigrateError’s for you, so you don’t need to worry about those
Published at 2017/06/24
Receiving new updates shouldn’t miss any anymore, also, periodic pings are back again so it should work on the long run.
On a different order of things,
.connect() also features a timeout.
Notice that the
timeout= is not passed as a parameter
anymore, and is instead specified when creating the
Published at 2017/06/16
This update brings a lot of changes, so it would be nice if you could read the whole change log!
- Every Telegram error has now its own class, so it’s easier to
- Markdown parsing is not part of Telethon itself anymore, although there are plans to support it again through a some external module.
.list_sessions()has been moved to the
InteractiveTelegramClientis not shipped with
- A new, more lightweight class has been added. The
TelegramBareClientis now the base of the normal
TelegramClient, and has the most basic features.
- New method to
.create_new_connection(), which can be ran in parallel with the original connection. This will return the previously mentioned
- Any file object can now be used to download a file (for instance, a
BytesIO()instead a file name).
- Vales like
random_idare now automatically inferred, so you can save yourself from the hassle of writing
generate_random_long()everywhere. Same applies to
.get_input_peer(), unless you really need the extra performance provided by skipping one
ifif called manually.
- Every type now features a new
- Received errors are acknowledged to the server, so they don’t happen over and over.
- Downloading media on different data centers is now up to x2
faster, since there used to be an
InvalidDCErrorfor each file part tried to be downloaded.
- Lost messages are now properly skipped.
- New way to handle the result of requests. The old
ValueError“The previously sent request must be resent. However, no request was previously sent (possibly called from a different thread).” should not happen anymore.
- Some fixes to the
- Fixed possibly crashes if trying to
.reconnect()was being called on the
- Some improvements on the
TcpClient, such as not switching between blocking and non-blocking sockets.
- The code now uses ASCII characters only.
- Some enhancements to
Published at 2017/06/07
This version is primarily for people to migrate their
files, which are pickled, to the new JSON format. Although slightly
slower, and a bit more vulnerable since it’s plain text, it’s a lot more
resistant to upgrades.
You must upgrade to this version before any higher one if you’ve
used Telethon ≤ v0.10. If you happen to upgrade to an higher version,
that’s okay, but you will have to manually delete the
and logout from that session from an official client.
.get_me()function to get the current user.
.is_user_authorized()is now more reliable.
- New nice button to copy the
from telethon.tl.xxx.yyy import Yyyon the online documentation.
- More error codes added to the
Published at 2017/06/03
Working with different data centers finally works! On a different order of things, reconnection is now performed automatically every time Telegram decides to kick us off their servers, so now Telethon can really run forever and ever! In theory.
- Documentation improvements, such as showing the return type.
msg_id too low/higherror should happen less often, if any.
- Sleeping on the main thread is not done anymore. You will have to
- You can now specify your own application version, device model, system version and language code.
- Code is now more pythonic (such as making some members private),
and other internal improvements (which affect the updates
thread), such as using
loggerinstead a bare
This brings Telethon a whole step closer to
v1.0, though more things
should preferably be changed.
Published at 2017/05/23
Telethon used to crash a lot when logging in for the very first time.
The reason for this was that the reconnection (or dead connections) were
not handled properly. Now they are, so you should be able to login
directly, without needing to delete the
*.session file anymore.
Notice that downloading from a different DC is still a WIP.
- Updates thread is only started after a successful login.
- Files meant to be ran by the user now use shebangs and proper permissions.
- In-code documentation now shows the returning type.
- Relative import is now used everywhere, so you can rename
telethonto anything else.
- Dead connections are now detected instead entering an infinite loop.
- Sockets can now be closed (and re-opened) properly.
- Telegram decided to update the layer 66 without increasing the number. This has been fixed and now we’re up-to-date again.
Published at 2017/05/19
|Scheme layer used: 66|
- The documentation, available online here, has a new search bar.
- Better cross-thread safety by using
- More improvements for running Telethon during a long period of time.
- Avoid a certain crash on login (occurred if an unexpected object ID was received).
- Avoid crashing with certain invalid UTF-8 strings.
- Avoid crashing on certain terminals by using known ASCII characters where possible.
UpdatesThreadis now a daemon, and should cause less issues.
- Temporary sessions didn’t actually work (with
Published at 2017/04/14
- Bot login, thanks to @JuanPotato for hinting me about how to do it.
- Proxy support, thanks to @exzhawk for implementing it.
- Logging support, used by passing
INFO) as a command line argument.
Published at 2017/02/19
If you’re one of those who runs Telethon for a long time (more than 30 minutes), this update by @strayge will be great for you. It sends periodic pings to the Telegram servers so you don’t get disconnected and you can still send and receive updates!
Published at 2017/01/31
|Scheme layer used: 62|
If you’re one of those who love security the most, these are good news. You can now use two factor authentication with Telethon too! As internal changes, the coding style has been improved, and you can easily use custom session objects, and various little bugs have been fixed.
Published at 2016/11/13
|Scheme layer used: 57|
This release has no new major features. However, it contains some small
changes that make using Telethon a little bit easier. Now those who have
installed Telethon via
pip can also take advantage of changes, such
as less bugs, creating empty instances of
TLObjects, specifying a
timeout and more!
Published at 2016/09/18
Telethon is now available as a `Python package <https://pypi.python.org/pypi?name=Telethon>`__! Those are really exciting news (except, sadly, the project structure had to change a lot to be able to do that; but hopefully it won’t need to change much more, any more!)
Not only that, but more improvements have also been made: you’re now able to both sign up and logout, watch a pretty “Uploading/Downloading… x%” progress, and other minor changes which make using Telethon easier.
Published at 2016/09/12
Yes, really cool! I promise. Even though this is meant to be a
library, that doesn’t mean it can’t have a good interactive client
for you to try the library out. This is why now you can do many, many
things with the
- List dialogs (chats) and pick any you wish.
- Send any message you like, text, photos or even documents.
- List the latest messages in the chat.
- Download any message’s media (photos, documents or even contacts!).
- Receive message updates as you talk (i.e., someone sent you a message).
It actually is an usable-enough client for your day by day. You could
libnotify and pop, you’re done! A great cli-client with
Also, being able to download and upload media implies that you can do the same with the library itself. Did I need to mention that? Oh, and now, with even less bugs! I hope.
Published at 2016/09/11
Telegram is more than an application to send and receive messages. You can also send and receive media. Now, this implementation also gives you the power to upload and download media from any message that contains it! Nothing can now stop you from filling up all your disk space with all the photos! If you want to, of course.
Published at 2016/09/10
This version handles updates in a different thread (if you wish to
do so). This means that both the low level
TcpClient and the
MtProtoSender are now multi-thread safe, so you can
use them with more than a single thread without worrying!
This also implies that you won’t need to send a request to receive an update (is someone typing? did they send me a message? has someone gone offline?). They will all be received instantly.
Some other cool examples of things that you can do: when someone tells you “Hello”, you can automatically reply with another “Hello” without even needing to type it by yourself :)
However, be careful with spamming!! Do not use the program for that!
Published at 2016/09/06
|Scheme layer used: 55|
There probably are some bugs left, which haven’t yet been found. However, the majority of code works and the application is already usable! Not only that, but also uses the latest scheme as of now and handles way better the errors. This tag is being used to mark this release as stable enough.