how can i host my telegram bot so that its available 24x7 using streamlit
modify my code 
import json
import numpy as np
import keras
from sklearn.preprocessing import LabelEncoder
import pickle
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.layers import LSTM
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Embedding
from telegram import Update
from telegram.ext import Updater, CommandHandler, MessageHandler, CallbackContext
from telegram.ext import Filters
#complete model training
with open('E:\Projects\chatbot\data\data.json', 'r') as f:
    data = json.load(f)
training_sentences = []
training_labels = []
labels = []
responses = []
for intent in data['intents']:
    for pattern in intent['patterns']:
        training_sentences.append(pattern)
        training_labels.append(intent['tag'])
    responses.append(intent['responses'])
    
    if intent['tag'] not in labels:
        labels.append(intent['tag'])   
num_classes = len(labels)
lbl_encoder = LabelEncoder()
lbl_encoder.fit(training_labels)
training_labels = lbl_encoder.transform(training_labels)
vocab_size = 2000
embedding_dim = 16
max_len = 30
oov_token = "<OOV>"
tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_token)
tokenizer.fit_on_texts(training_sentences)
word_index = tokenizer.word_index
sequences = tokenizer.texts_to_sequences(training_sentences)
padded_sequences = pad_sequences(sequences, truncating='post', maxlen=max_len)

model = Sequential()
model.add(Embedding(vocab_size, embedding_dim, input_length=max_len))
model.add(LSTM(16, return_sequences=False))
model.add(Dense(16, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))

model.compile(loss='sparse_categorical_crossentropy', 
              optimizer='adam', metrics=['accuracy'])

model.summary()
epochs = 300
history = model.fit(padded_sequences, np.array(training_labels), epochs=epochs)

# to save the trained model
model.save("E:\Projects\chatbot\models\chat_model.h5")

import pickle

# to save the fitted tokenizer
with open('E:\\Projects\\chatbot\\models\\tokenizer.pickle', 'wb') as handle:
    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
    
# to save the fitted label encoder
with open('E:\\Projects\\chatbot\\models\\label_encoder.pickle', 'wb') as ecn_file:
    pickle.dump(lbl_encoder, ecn_file, protocol=pickle.HIGHEST_PROTOCOL)
#loading and telegram deployment
with open(r"E:\Projects\chatbot\data\data.json") as file:
    data = json.load(file)

def start(update: Update, context: CallbackContext) -> None:
    """Send a message when the command /start is issued."""
    update.message.reply_text('Hi, I\'m your chatbot. How can I help you?')
                              
def chatbot_response(update: Update, context: CallbackContext) -> None:
    model = keras.models.load_model(r'E:\Projects\chatbot\models\chat_model.h5')
    with open(r'E:\Projects\chatbot\models\tokenizer.pickle', 'rb') as handle:
        tokenizer = pickle.load(handle)

    with open(r'E:\Projects\chatbot\models\label_encoder.pickle', 'rb') as enc:
        lbl_encoder = pickle.load(enc)

    # parameters
    max_len = 30

    # Get the message from the user
    message = update.message.text
    # Convert input message into sequence of integers using tokenizer
    msg_seq = tokenizer.texts_to_sequences([message])
    # Pad the sequence to have fixed length
    msg_seq = pad_sequences(msg_seq, maxlen=max_len, truncating='post')
    
    # Predict the class of the input message
    pred = model.predict(msg_seq)[0]
    # Get the index of the predicted class
    pred_idx = np.argmax(pred)
    # Get the confidence of the prediction
    confidence = pred[pred_idx]
    # Convert the index back to the original label
    tag = lbl_encoder.inverse_transform([pred_idx])[0]

    # If the confidence is less than 0.5, send a default message
    if confidence < 0.75:
        context.bot.send_message(chat_id=update.effective_chat.id, text="I'm sorry, but I didn't understand your concern. Please keep it simple, rephrase the sentence or try asking something else related to mental health")
    else:
        for i in data['intents']:
            if i['tag'] == tag:
                response = np.random.choice(i['responses'])
                # Send the response to the user
                context.bot.send_message(chat_id=update.effective_chat.id, text=response)
                break

def main() -> None:
    # Create the Updater and pass it your bot's token.
    updater = Updater("myapikey",use_context=True)

    # Get the dispatcher to register handlers
    dispatcher = updater.dispatcher

    # on different commands - answer in Telegram
    dispatcher.add_handler(CommandHandler("start", lambda update, context: start(update, context)))

    # on noncommand i.e message - echo the message on Telegram
    dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command,
                                          lambda update, context: chatbot_response(update, context)))

    # Start the Bot
    updater.start_polling()

    # Run the bot until you press Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the
    updater.idle()


if __name__ == '__main__':
    main()