https://github.com/Eloise1988/OPENAI/blob/main/asyncV2/README.md
api_id: Telegram API ID and Hash (you can get it from my.telegram.org) api_hash : Telegram API Hash (you can get it from my.telegram.org) session_hash : Telegram Session Hash (you can get it from my.telegram.org)
I found api_id and api_hash, but I didn't find session_hash
from telethon import TelegramClient
api_id = 123456 # Your API ID
api_hash = 'your_api_hash' # Your API Hash
# Create a new TelegramClient instance and start the client
async with TelegramClient('session_file', api_id, api_hash) as client:
# Connect to the Telegram servers and log in
await client.start()
# After logging in, the session hash will be automatically generated and stored
# in the 'session_file' file, which you can use in future runs to log in with
# the same session:
session_hash = client.session.save()
print(str(session_hash))
I try to make a program to get the content of a Telegram Channel using Telethon (I'm begginer) :
from telethon import TelegramClient, events, sync
# Remember to use your own values from my.telegram.org!
api_id = 12345678
api_hash = "zdzhdzud"
client = TelegramClient(None, api_id, api_hash)
#client.on(events.NewMessage(chats='Channel_Test'))
async def my_event_handler(event):
print("\n\n\n",event.raw_text,"\n\n\n")
client.start()
client.run_until_disconnected()
I get "RuntimeWarning: Enable tracemalloc to get the object allocation traceback" 2 times.
Thank you
I expected to get a str for each message
What I have: gRPC endpoint which sends a stream of message updates in response.
What I want to test: I want to create a load test that will open a stream, get multiple messages until a message with a specific field will not be captured (within defined timeout). (Without an explicit call of pause method and waiting for some time).
What I get from Gatling-gRPC:
After an explicit call of pause() method, the reconciliation method is returning the last captured message.
Example server: here
Protofile: here
Test code:
package load.api
import com.github.phisgr.gatling.generic.SessionCombiner
import com.github.phisgr.gatling.grpc.Predef._
import example.myapp.helloworld.grpc.hello_world.{GreeterServiceGrpc, HelloRequest}
import io.gatling.core.Predef._
import io.grpc.{CallOptions, Status}
import java.util.concurrent.TimeUnit
import scala.concurrent.duration.DurationInt
import scala.language.postfixOps
class StreamSim extends Simulation {
val greetCall = grpc("Greet")
.serverStream("greeter")
val scn = scenario(s"Greet Flow")
.exec(greetCall.start(GreeterServiceGrpc.METHOD_IT_KEEPS_REPLYING)
(HelloRequest("THIS IS TEST MESSAGE"))
.extract(_.some.get.message.some)(_ saveAs "message")
.sessionCombiner(SessionCombiner.pick("message"))
.endCheck(statusCode is Status.Code.OK)
)
.pause(10 seconds)
.exec(greetCall.copy(requestName = "Reconciliate greet").reconciliate)
.exec { session =>
println(s"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%> Last character of the message: ${session.attributes("message")}")
session
}
setUp(scn.inject(rampUsers(1) during (10 seconds))
.protocols(grpc(managedChannelBuilder(name = "127.0.0.1", port = 8080).usePlaintext()).shareChannel.disableWarmUp))
}
How do I forward a message to another chat as soon as I receive it from a contact?
I created this example just to test routing, but it doesn't work.
#!/usr/local/bin/python3
from telethon import TelegramClient, events
api_id = 9999900
api_hash = 'xxxxxxxxxxxxxxxxxxxxxxxxxxx'
client = TelegramClient('session_name', api_id, api_hash)
client.start()
#client.on(events.NewMessage)
async def main(event):
await client.send_message('Other People', 'Hello!') #Don't work. Keeps waiting forever
with client:
client.run_until_disconnected()
#client.on(events.NewMessage)
async def main(event):
await client.forward_messages(entity, event.message)
This code will work for forwarding new messages.
You can simply put chat_id of target user in place of entity
Is there any way to find a telegram channel id without sending a message to it ?
Right now I go this way and find the channel id by calling this URL in my code and get the JSON as result:
https://api.telegram.org/bot???????/sendMessage?chat_id=#?????&text=123
However, this cause sending the message "123" to the channel which is not good.
Check this link for help.
It is using web telegram url param info.
Adding details from the referred link:
log in web telegram
Click on the target channel then you will find the url displayed on your browser.
If it's a public channel, the ID is #name of the channel.
If it's a private channel then the url must be similar to:
https://web.telegram.org/#/im?p=c1018013852_555990343349619165
For this case, the channel ID would be 1018013852.
It's important to know that channel's IDs are always negative and 13 characters long!
So add -100 to it, making the correct ID -1001018013852.
You Can use Web Telegram to see each channel id in link of that page in your explorer
or
Just Simply Forward a message from your channel to This Bot: (https://telegram.me/getidsbot)
Yes, just forward a message of the channel to your bot and get the message.forward_from_chat.id.
Get your channel link
install python library telethon
get your api_id and api_hash here.
write the following code and run:
from telethon import TelegramClient
api_id=
api_hash=
channel_link = 'your_channel_link'
client = TelegramClient(session_name, api_id, api_hash,
update_workers=4, spawn_read_thread=False)
client.start()
entity = client.get_input_entity(**channel_link**)
print(entity.channel_id)
By the way, if you use it for telegram bot, just add -100 before the printed id, this should be work!
You Don't Need to get Channels ID .
simple send Message with Channel User Like : #channel
Fixing #scruel's answer:
In [1]: api_id = ...
In [2]: api_hash = '...'
In [3]: channelLink = 'https://t.me/BTCST_Community_EN'
In [4]: from telethon import TelegramClient, events
In [5]: client = TelegramClient('test', api_id, api_hash)
In [6]: client.start()
Out[6]: <telethon.client.telegramclient.TelegramClient at 0x7fc90c352290>
In [7]: entity = await client.get_entity(channelLink)
In [8]: channelId = '-100' + str(entity.id)
In [9]: channelId
Out[9]: '-1001236496320'
Here's a CLI util to do it:
#!env/bin/python
import sys
import asyncio
from telethon import TelegramClient
import config
async def channel_id_from_link(client, channel_link):
return "-100" + str((await client.get_entity(channel_link)).id)
async def main(channel_link):
async with TelegramClient(
"test", config.api_id, config.api_hash
) as client:
channel_id = await channel_id_from_link(client, channel_link)
return channel_id
if __name__ == "__main__":
channel_link = sys.argv[1]
channel_id = asyncio.run(main(channel_link))
print(channel_id)
Test:
> ./TelegramChannelId.py https://t.me/binance_api_english
-1001134190352
Put your bot into your channel and go to https://api.telegram.org/bot/getUpdates.
If someone send message to that channel, you will get the channel ID there.