mtproto | Telegram MTProto and its proxy in Go ( golang | Proxy library

TdLib is what you looking for!

TDLib (Telegram Database Library) is a cross-platform, fully functional Telegram client. We designed it to help third-party developers create their own custom apps using the Telegram platform.

TdLib supports multiple languages and has a JSON interface for other languages. So don't worry about your programming language.

It even abstracts whether the internet is connected or not, downloads multiple files based on priority, and so on. I strongly suggest you use TdLib.

https://core.telegram.org/tdlib

https://github.com/tdlib/td

After a long time and didn't get an answer, I asked the question in the TensorFlow's forum and get the answer. It seems that the current version of TensorFlow has a problem with loading decision forests with C_API. So we can use the Yggdrasil library as discussed in the answer.

Yes. A new setting has been added called Restrict Saving Content (or content protection)

Any channel owner can enable it which will prevent users from forwarding and even copying content including text.

It's contacts.getLocated, which returns both users and groups

You can easily create what's known as a "finite state machine" (FSM) that is able to differentiate between the different states of a conversation a user can find themselves in.

NIO is basically used on the server side to handle large scale. I'll try to explain how a typical server works.

A server has a requests queue, from which a polling thread consumes connections as a blocking dequeue operation (In Java, the default length of the requests queue is 50. It means if you try to initiate the 51st connection while the request queue is full, you'll get ConnectionRefused exception).

A typical blocking implementation goes like this:

1. Server accepts connection and puts it on the requests queue.

2. A polling thread consumes connections from the head of the queue and dispatches it to a thread pool. The polling thread becomes free if the thread-pool queue is not full and continues consuming connections from the queue.

3. At some point, all the threads in the thread-pool will become busy and the polling thread will get blocked while submitting more connections to the pool (as the thread-pool queue is a blocking queue).

4. The requests queue starts filling up in the meantime. At some point, it'll get completely full and the server will no longer accept any connections.

At this point, our server just can't scale anymore. Note that the "busy" threads in the pool might not be busy at all but just blocked - say for more data on the InputStream of the respective socket they are serving.

Now consider this design:

1. The polling thread consumes items from the head of the requests queue.

2. It puts it on a unbounded list.

3. Another thread continuously iterates over this list and checks if any activity has happened on the socket (read to read, ready to write, etc). If there is an activity, the socket is served. Note that these sockets operate in the NIO mode. That is, if there is no activity, our thread won't get blocked.

4. The polling thread continues to submit connections to the list in the meantime as the list is unbounded. It does not get blocked anywhere (except while it is waiting for a new connection on the requests queue).

In the above design, note that our scale is limited only by our system resources - namely how many connections the list hold. The response time will take a hit as there is just one thread servicing all the connections. You CPU consumption will be pretty high due to the mindless iteration. But you will still be able to connect to the server, unlike in the previous design.

NIO basically solves this problem by using selectors.

MTProto servers will close your connection (under TCP at least) if they can't understand what you've sent it; messages sent that have some incorrect parameter will typically receive a reply indicating parameters were incorrect but messages whose composition is fundamentally wrong, e.g: sending the transport code with each message instead of just the first will lead to the connection being closed. Check the code that handles the transport layer for correctness against https://core.telegram.org/mtproto/transports#tcp

That cannot be done because Bot API uses https requests to communicate while MTProtoProxy proxies are meant for MTProto API (used by telegram clients) which is different from the Bot API.

You would need to use a normal HTTP/socks proxy in order to avoid the ban which can be found at this page https://telegrambots.github.io/book/4/proxy.html