async def on_file_to_photo(event):
"image file(png) to streamable image."
target = await event.get_reply_message()
try:
image = target.media.document
except AttributeError:
return await edit_delete(event, "`This isn't an image`")
if not image.mime_type.startswith("image/"):
return await edit_delete(event, "`This isn't an image`")
if image.mime_type == "image/webp":
return await edit_delete(event, "`For sticker to image use stoi command`")
if image.size > 10 * 1024 * 1024:
return # We'd get PhotoSaveFileInvalidError otherwise
catt = await edit_or_reply(event, "`Converting.....`")
file = await event.client.download_media(target, file=BytesIO())
file.seek(0)
img = await event.client.upload_file(file)
img.name = "image.png"
try:
await event.client(
SendMediaRequest(
peer=await event.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id,
)
)
except PhotoInvalidDimensionsError:
return
await catt.delete()
async def on_file_to_photo(event):
await event.delete()
target = await event.get_reply_message()
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith('image/'):
return # This isn't an image
if image.mime_type == 'image/webp':
return # Telegram doesn't let you directly send stickers as photos
if image.size > 10 * 1024 * 1024:
return # We'd get PhotoSaveFileInvalidError otherwise
file = await borg.download_media(target, file=BytesIO())
file.seek(0)
img = await borg.upload_file(file)
img.name = 'image.png'
try:
await borg(
SendMediaRequest(peer=await event.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id))
except PhotoInvalidDimensionsError:
return
async def on_file_to_photo(event):
if event.fwd_from:
return
target = await event.get_reply_message()
hbot = await edit_or_reply(event, "Converting.....")
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith("image/"):
return # This isn't an image
if image.mime_type == "image/webp":
return # Telegram doesn't let you directly send stickers as photos
if image.size > 10 * 1024 * 1024:
return # We'd get PhotoSaveFileInvalidError otherwise
file = await event.client.download_media(target, file=BytesIO())
file.seek(0)
img = await event.client.upload_file(file)
img.name = "image.png"
try:
await event.client(
SendMediaRequest(
peer=await event.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id,
)
)
except PhotoInvalidDimensionsError:
return
await hbot.delete()
async def on_file_to_photo(pics):
await pics.edit("Converting Document image to Full Size Image\nPlease wait...")
await sleep(1.5)
await pics.delete()
target = await pics.get_reply_message()
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith('image/'):
return # This isn't an image
if image.mime_type == 'image/webp':
return # Telegram doesn't let you directly send stickers as photos
if image.size > 10 * 2560 * 1440:
return # We'd get PhotoSaveFileInvalidError otherwise
file = await pics.client.download_media(target, file=BytesIO())
file.seek(0)
img = await pics.client.upload_file(file)
img.name = 'image.png'
try:
await pics.client(SendMediaRequest(
peer=await pics.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id
))
except PhotoInvalidDimensionsError:
return
async def tgr_send(event: NewMessage.Event) -> None:
if not event.reply_to_msg_id:
await event.answer("`I need a retard to proceed!`")
return
reply = await event.get_reply_message()
# Forward the message to TGR
await client.forward_messages(entity=tgr_entity,
messages=reply,
silent=True,
from_peer=reply.chat_id)
divider = client(
GetStickersRequest(emoticon='❤', hash=-1447283942124334054))
# Send the divider sticker
await client(
SendMediaRequest(
entities=tgr_entity,
message='',
peer=client.get_entity("hyperterminal"),
media=InputMediaDocument(
id=InputDocument(id=divider.id,
access_hash=divider.access_hash,
file_reference=divider.file_reference))))
await event.answer(f"`{random.choice(SUCCESS_MESSAGES)}`")
async def on_file_to_photo(pics):
sender = await pics.get_sender() ; me = await pics.client.get_me()
if not sender.id == me.id:
rkp = await pics.reply("`processing`")
else:
rkp = await pics.edit("`processing`")
await rkp.edit("Converting Document image to Full Size Image\nPlease wait...")
await sleep(2.5)
await pics.delete()
target = await pics.get_reply_message()
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith('image/'):
return
if image.mime_type == 'image/webp':
return
if image.size > 10 * 2560 * 1440:
return
file = await pics.client.download_media(target, file=BytesIO())
file.seek(0)
img = await pics.client.upload_file(file)
img.name = 'image.png'
try:
await pics.client(SendMediaRequest( peer=await pics.get_input_chat(), media=types.InputMediaUploadedPhoto(img), message=target.message, entities=target.entities, reply_to_msg_id=target.id ))
except PhotoInvalidDimensionsError:
return await pics.reply("Error")
async def on_file_to_photo(pics):
xx = await edit_or_reply(pics, "`Processing...`")
await sleep(1.5)
await pics.delete()
target = await pics.get_reply_message()
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith("image/"):
return
if image.mime_type == "image/webp":
return
if image.size > 10 * 2560 * 1440:
return
file = await pics.client.download_media(target, file=BytesIO())
file.seek(0)
img = await pics.client.upload_file(file)
img.name = "image.png"
await xx.delete()
try:
await pics.client(
SendMediaRequest(
peer=await pics.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id,
))
except PhotoInvalidDimensionsError:
return
async def on_file_to_photo(pics):
await pics.edit(
"Mengonversi gambar Dokumen ke Gambar Ukuran Penuh\nTunggu sebentar..."
)
await sleep(1.5)
await pics.delete()
target = await pics.get_reply_message()
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith("image/"):
return # This isn't an image
if image.mime_type == "image/webp":
return # Telegram doesn't let you directly send stickers as photos
if image.size > 10 * 2560 * 1440:
return # We'd get PhotoSaveFileInvalidError otherwise
file = await pics.client.download_media(target, file=BytesIO())
file.seek(0)
img = await pics.client.upload_file(file)
img.name = "image.png"
try:
await pics.client(
SendMediaRequest(
peer=await pics.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id,
))
except PhotoInvalidDimensionsError:
return
def send_media_file(self, input_media, entity):
"""Sends any input_media (contact, document, photo...) to the given entiy"""
self.invoke(
SendMediaRequest(
peer=get_input_peer(entity),
media=input_media,
random_id=utils.generate_random_long()))
async def send_media(self, entity: Union[TypeInputPeer, TypePeer],
media: Union[TypeInputMedia, TypeMessageMedia],
caption: str = None, entities: List[TypeMessageEntity] = None,
reply_to: int = None) -> Optional[Message]:
entity = await self.get_input_entity(entity)
reply_to = utils.get_message_id(reply_to)
request = SendMediaRequest(entity, media, message=caption or "", entities=entities or [],
reply_to_msg_id=reply_to)
return self._get_response_message(request, await self(request), entity)
async def send_file(self, entity, file, mime_type=None, caption=None, entities=None,
attributes=None, file_name=None, reply_to=None, **kwargs):
entity = await self.get_input_entity(entity)
reply_to = self._get_message_id(reply_to)
file_handle = await self.upload_file(file, file_name=file_name, use_cache=False)
if mime_type == "image/png" or mime_type == "image/jpeg":
media = InputMediaUploadedPhoto(file_handle)
else:
attributes = attributes or []
attr_dict = {type(attr): attr for attr in attributes}
media = InputMediaUploadedDocument(
file=file_handle,
mime_type=mime_type or "application/octet-stream",
attributes=list(attr_dict.values()))
request = SendMediaRequest(entity, media, message=caption or "", entities=entities or [],
reply_to_msg_id=reply_to)
return self._get_response_message(request, await self(request))
def send_file(client, entity, file, dur, title, artist, caption):
file_hash = hash(file)
if file_hash in client._upload_cache: file_handle = client._upload_cache[file_hash]
else: client._upload_cache[file_hash] = file_handle = client.upload_file(file)
attr_dict = {
DocumentAttributeFilename:
DocumentAttributeFilename(caption),
DocumentAttributeAudio:
DocumentAttributeAudio(int(dur), title=title, performer=artist)
}
media = InputMediaUploadedDocument(
file=file_handle,
mime_type='audio/mpeg',
attributes=list(attr_dict.values()),
caption=''
)
client(SendMediaRequest(
peer=client.get_input_entity(entity),
media=media,
reply_to_msg_id=None
))
async def on_file_2_photo(event):
await event.delete()
target = await event.get_reply_message()
try:
image = target.media.document
except AttributeError:
return
if not image.mime_type.startswith('image/'):
return
if image.mime_type == 'image/webp':
return
if image.size > 10 * 1024 * 1024:
return
file = await event.client.download_media(target, file=BytesIO())
file.seek(0)
img = await event.client.upload_file(file)
img.name = 'image.png'
try:
await event.client(SendMediaRequest(
peer=await event.get_input_chat(),
media=types.InputMediaUploadedPhoto(img),
message=target.message,
entities=target.entities,
reply_to_msg_id=target.id
))
except PhotoInvalidDimensionsError:
return
def send_media_file(self, input_media, input_peer):
"""Sends any input_media (contact, document, photo...) to an input_peer"""
self.invoke(SendMediaRequest(peer=input_peer,
media=input_media,
random_id=utils.generate_random_long()))
async def send_media(self, entity, media, caption=None, entities=None, reply_to=None):
request = SendMediaRequest(entity, media, message=caption or "", entities=entities or [],
reply_to_msg_id=reply_to)
return self._get_response_message(request, await self(request))