chatgpt_assistant 0.1.0

data/lib/bots/telegram_bot.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible for the telegram bot features
+  class TelegramBot < ApplicationBot
+    def start
+      start_log
+      bot.listen do |message|
+        @msg = message
+        next unless text_or_audio?
+
+        message_received_log
+        message_text_cases if msg.text.present?
+        message_audio_process if msg.audio.present? || msg.voice.present?
+      end
+    end
+
+    private
+
+    attr_accessor :msg
+
+    def message_text_cases
+      logger.log("MESSAGE TEXT: TRUE")
+      case msg.text
+      when "/start"
+        run_start
+      when "/help"
+        run_help
+      when "/list"
+        list_chats
+      when "/stop"
+        run_stop
+      when "/hist"
+        run_hist
+      when nil
+        run_nil_error
+      else
+        operations
+      end
+    end
+
+    def message_audio_process
+      logger.log("MESSAGE AUDIO: TRUE")
+      return bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected]) if user.current_chat_id.nil? || user.current_chat_id.zero?
+      chat = Chat.find(user.current_chat_id)
+      message_create(transcribed_text, chat.id, "user")
+      text = chatter.chat(transcribed_text, chat.id)
+      voice = audio_synthesis.synthesize_text(text)
+      bot.api.send_message(chat_id: msg.chat.id, text: text)
+      bot.api.send_voice(chat_id: msg.chat.id, voice: Faraday::UploadIO.new(voice, "audio/mp3"))
+      delete_all_voice_files
+    end
+
+    def operations
+      return chatter_call unless actions?
+      return new_chat if msg.text.include?("new_chat/")
+      return select_chat if msg.text.include?("sl_chat/")
+      return login if msg.text.include?("login/")
+      return register if msg.text.include?("register/")
+      invalid_command_error_message
+    end
+
+    def login
+      user_info = msg.text.split("/").last
+      email, password = user_info.split(":")
+      case auth_usertelegram(email, password, msg.chat.id)
+      when "user not found"
+        user_not_found_error_message
+      when "wrong password"
+        wrong_password_error_message
+      when find_usertelegram(email)
+        user_logged_in_message
+      end
+    end
+
+    def register
+      user_info = msg.text.split("/").last
+      email, password = user_info.split(":")
+      if telegram_user_create(msg.chat.id, email, password, msg.from.username || msg.from.first_name)
+        user_created_message
+      else
+        user_creation_error_message
+      end
+    end
+
+    def audio
+      msg.audio || msg.voice
+    end
+
+    def audio_info
+      bot.api.get_file(file_id: audio.file_id)
+    end
+
+    def audio_url
+      "https://api.telegram.org/file/bot#{telegram_token}/#{audio_info["result"]["file_path"]}"
+    end
+
+    def transcribed_text
+      audio_recognition.transcribe_audio(audio_url)
+    end
+
+    def run_start
+      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:start])
+      help_message = help_messages.join("\n").to_s
+      bot.api.send_message(chat_id: msg.chat.id, text: help_message)
+      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:start_helper])
+      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:start_sec_helper])
+    end
+
+    def run_hist
+      return not_logged_in_message unless user
+
+      chat = Chat.find(user.current_chat_id)
+      if chat
+        if chat.messages.count.zero?
+          return bot.api.send_message(chat_id: msg.chat.id,
+                                               text: error_messages[:no_messages_founded])
+        end
+
+        response = chat.messages.last(4).map do |mess|
+          "#{mess.role}: #{mess.content}\n at: #{mess.created_at}\n\n"
+        end.join
+        logger.log("HIST RESPONSE: #{response}")
+        bot.api.send_message(chat_id: msg.chat.id, text: response)
+      else
+        bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected])
+      end
+    end
+
+    def select_chat
+      if user.nil?
+        not_logged_in_message
+      else
+        chat = Chat.find_by(user: user, title: msg.text.split("/").last)
+        if chat
+          user.update(current_chat_id: chat.id)
+          bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:chat_selected])
+        else
+          chat_not_found_message
+        end
+      end
+    end
+
+    def new_chat
+      user.nil? ? not_logged_in_message : create_chat
+    end
+
+    def create_chat
+      text = msg.text
+      title = text.split("/").last
+      chat = Chat.new(user_id: user.id, status: 0, title: title)
+      chat.save ? chat_created_message(chat) : chat_creation_failed_message
+    end
+
+    def list_chats
+      chats = Chat.where(user_id: User.find_by(telegram_id: msg.chat.id).id)
+      return bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:no_chats_founded]) if chats.count.zero?
+      bot.api.send_message(chat_id: msg.chat.id,
+                                    text: commom_messages[:chats_list])
+      chats_str = ""
+      chats.each do |chat|
+        chats_str += "Chat #{chat.id} - #{chat.title}\n"
+      end
+      bot.api.send_message(chat_id: msg.chat.id, text: chats_str)
+    end
+
+    def chatter_call
+      user ? chat_if_exists : not_logged_in_message
+    end
+
+    def chat_if_exists
+      chat = Chat.find_by(user_id: user.id, id: user.current_chat_id)
+      chat ? chat_success(chat.id) : no_chat_selected
+    end
+
+    def chat_success(chat_id)
+      Message.create(chat_id: chat_id, content: msg.text, role: "user")
+      bot.api.send_message(chat_id: msg.chat.id, text: chatter.chat(msg.text, chat_id))
+    end
+
+    def run_help
+      help_messages.each do |message|
+        bot.api.send_message(chat_id: msg.chat.id, text: message)
+      end
+    end
+
+    def run_stop
+      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:stop])
+      bot.api.leave_chat(chat_id: msg.chat.id)
+    end
+
+    def run_nil_error
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:nil])
+    end
+
+    def user_logged_message
+      user.update(telegram_id: msg.chat.id)
+      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in])
+    end
+
+    def invalid_command_error_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:invalid_command])
+    end
+
+    def wrong_password_error_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:password])
+    end
+
+    def user_not_found_error_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_found])
+    end
+
+    def not_logged_in_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_logged_in])
+    end
+
+    def user_created_message
+      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:user_created])
+    end
+
+    def user_creation_error_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:user_creation])
+    end
+
+    def chat_created_message(chat)
+      user.update(current_chat_id: chat.id)
+      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:chat_created])
+    end
+
+    def chat_creation_failed_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:chat_creation_failed])
+    end
+
+    def no_chat_selected
+      bot.api.send_message(chat_id: msg.chat.id,
+                                    text: error_messages[:no_chat_selected])
+    end
+
+    def chat_not_found_message
+      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:chat_not_found])
+    end
+
+    def start_log
+      logger.log("STARTING BOT AT #{Time.now}")
+      logger.log("ENVIRONMENT: #{@config.env_type}")
+    end
+
+    def error_log(err)
+      if err.message.to_s.include?("Bad Request: message is too long")
+        bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:message_history_too_long])
+      else
+        bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:something_went_wrong])
+        bot.api.send_message(chat_id: msg.chat.id, text: "ERROR: #{err.message}\n #{err.backtrace}")
+      end
+      logger.log("ERROR: #{err.message}\n #{err.backtrace}")
+    end
+
+    def message_received_log
+      logger.log("MESSAGE RECEIVED AT: #{Time.now}")
+      logger.log("MESSAGE FROM USER: #{msg.from.first_name} #{msg.from.last_name} - #{msg.from.username}")
+    end
+
+    def user
+      @user ||= User.find_by(telegram_id: msg.chat.id)
+    end
+
+    def bot
+      @bot ||= Telegram::Bot::Client.new(telegram_token)
+    end
+
+    def text_or_audio?
+      msg.respond_to?(:text) || msg.respond_to?(:audio) || msg.respond_to?(:voice)
+    end
+
+    def actions?
+      msg.text.include?("new_chat/") || msg.text.include?("sl_chat/") || msg.text.include?("login/") || msg.text.include?("register/")
+    end
+  end
+end

data/lib/chatgpt_assistant/audio_recognition.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This is the AudioRecognition class
+  class AudioRecognition
+    def initialize(openai_api_key)
+      @conn = Faraday.new(url: "https://api.openai.com/") do |faraday|
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+      end
+      @logger = ChatterLogger.new
+      @openai_api_key = openai_api_key
+    end
+
+    def download_audio(audio_url)
+      logger.log("DOWNLOADING AUDIO FROM TELEGRAM")
+      @time = Time.now.to_i
+      audio_conn = Faraday.new(url: audio_url)
+      File.open("voice/audio-#{time}.oga", "wb") do |file|
+        file.write(audio_conn.get.body)
+      end
+
+      FFMPEG::Movie.new("voice/audio-#{time}.oga").transcode("voice/audio-#{time}.mp3")
+      File.delete("voice/audio-#{time}.oga")
+    end
+
+    def header
+      {
+        "Content-Type": "multipart/form-data",
+        "Authorization": "Bearer #{openai_api_key}"
+      }
+    end
+
+    def payload
+      {
+        "file": Faraday::UploadIO.new("voice/audio-#{time}.mp3", "audio/mp3"),
+        "model": "whisper-1"
+      }
+    end
+
+    def transcribe_audio(audio_url)
+      @audio_url = audio_url
+      download_audio(audio_url)
+      response = conn.post("v1/audio/transcriptions", payload, header)
+      logger.log("RESPONSE FROM OPENAI API AUDIO TRANSCRIPTION")
+      JSON.parse(response.body)["text"]
+    end
+
+    private
+
+    attr_reader :conn, :openai_api_key, :logger, :audio_url, :time, :ibm_api_key, :ibm_url
+  end
+end

data/lib/chatgpt_assistant/audio_synthesis.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible for synthesize text to speech
+  # This class can work with IBM Cloud or AWS Polly for synthesize text into speech
+  class AudioSynthesis
+    def initialize(config)
+      @config = config
+      @openai_api_key = config.openai_api_key
+      @language = config.language
+      @conn = faraday_instance
+      @logger = ChatterLogger.new
+      classify_mode
+    end
+
+    def synthesize_text(text)
+      if ibm_mode?
+        synthesize_text_ibm(text)
+      elsif aws_mode?
+        synthesize_text_aws(text)
+      end
+    end
+
+    private
+
+    attr_reader :openai_api_key, :ibm_api_key, :ibm_url, :aws_access_key_id, :aws_secret_access_key, :aws_region,
+                :config, :logger, :language, :voice
+
+    def faraday_instance
+      Faraday.new(url: "https://api.openai.com/") do |faraday|
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def classify_mode
+      if ibm_mode?
+        @ibm_api_key = config.ibm_api_key
+        @ibm_url = config.ibm_url
+        @voice = send("#{language}_ibm_voice")
+      elsif aws_mode?
+        @aws_access_key_id = config.aws_access_key_id
+        @aws_secret_access_key = config.aws_secret_access_key
+        @aws_region = config.aws_region
+        @voice = send("#{language}_aws_voice")
+      end
+    end
+
+    def synthesize_text_aws(text)
+      time = Time.now.to_i
+      logger.log("SYNTHESIZING TEXT WITH AWS POLLY")
+      @time = Time.now.to_i
+      polly_client = Aws::Polly::Client.new(
+        access_key_id: aws_access_key_id,
+        secret_access_key: aws_secret_access_key,
+        region: aws_region
+      )
+      response = polly_client.synthesize_speech(
+        output_format: "mp3",
+        text: text,
+        voice_id: voice,
+        engine: "neural"
+      )
+
+      File.open("voice/aws-#{time}.mp3", "wb") do |file|
+        file.write(response.audio_stream.read)
+      end
+
+      logger.log("SYNTHESIZED TEXT WITH AWS POLLY")
+      "voice/aws-#{time}.mp3"
+    end
+
+    def synthesize_text_ibm(text)
+      time = Time.now.to_i
+      logger.log("SYNTHESIZING TEXT WITH IBM WATSON")
+      authenticator = IBMWatson::Authenticators::IamAuthenticator.new(
+        apikey: ibm_api_key
+      )
+
+      text_to_speech = IBMWatson::TextToSpeechV1.new(
+        authenticator: authenticator
+      )
+
+      text_to_speech.service_url = ibm_url
+
+      audio_format = "audio/mp3"
+      audio = text_to_speech.synthesize(
+        text: text,
+        accept: audio_format,
+        voice: voice
+      ).result
+
+      File.open("voice/ibm-#{time}.mp3", "wb") do |audio_file|
+        audio_file.write(audio)
+      end
+      "voice/ibm-#{time}.mp3"
+    end
+
+    def pt_aws_voice
+      "Vitoria"
+    end
+
+    def en_aws_voice
+      "Joanna"
+    end
+
+    def pt_ibm_voice
+      "pt-BR_IsabelaV3Voice"
+    end
+
+    def en_ibm_voice
+      "en-US_AllisonV3Voice"
+    end
+
+    def ibm_mode?
+      config.mode == "ibm"
+    end
+
+    def aws_mode?
+      config.mode == "aws"
+    end
+  end
+end

data/lib/chatgpt_assistant/chatter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "faraday"
+require_relative "models"
+require_relative "chatter_logger"
+
+module ChatgptAssistant
+  # This is the Chat Ai class
+  class Chatter
+    def initialize(openai_api_key)
+      @openai_api_key = openai_api_key
+      @logger = ChatterLogger.new
+    end
+
+    def chat(message, chat_id)
+      @chat_id = chat_id
+      @message = message
+      init_log
+      @response = request(message)
+      @json = JSON.parse(response.body)
+      logger.log("RESPONSE FROM OPENAI API: OK")
+
+      return error_log if response.status != 200
+
+      text = json["choices"][0]["message"]["content"]
+
+      Message.create(content: text, role: "assistant", chat_id: chat_id)
+      logger.log("MESSAGE SAVED IN DATABASE")
+      text
+    end
+
+    private
+
+    attr_reader :openai_api_key, :response, :message, :logger
+    attr_accessor :chat_id, :json
+
+    def init_log
+      logger.log("REQUESTING OPENAI API COMPLETION")
+    end
+
+    def error_log
+      logger.log("RESPONSE FROM OPENAI API ERROR")
+      logger.log("RESPONSE STATUS: #{response.status}")
+      "Algo deu errado, tente novamente mais tarde."
+    end
+
+    def header
+      {
+        "Content-Type": "application/json",
+        Authorization: "Bearer #{openai_api_key}"
+      }
+    end
+
+    def connection
+      Faraday.new(url: "https://api.openai.com/") do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def request_params(message)
+      messages = Message.where(chat_id: chat_id).order(id: :asc).last(10)
+      if messages.empty?
+        ids = ["unknown"]
+        messages = [{ role: "user", content: message }]
+      else
+        ids = messages.map(&:id)
+        messages = messages.map { |mess| { role: mess.role, content: mess.content } }
+      end
+      logger.log("MESSAGES LOADED IN CONTEXT: #{messages.count}")
+      messages.each_with_index do |mess, index|
+        logger.log("MESSAGE ROLE: #{mess[:role]}, ID: #{ids[index]}")
+      end
+      {
+        model: "gpt-3.5-turbo",
+        messages: messages
+      }.to_json
+    end
+
+    def request(message)
+      connection.post("v1/chat/completions", request_params(message), header)
+    end
+  end
+end

data/lib/chatgpt_assistant/chatter_logger.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible for logging the messages
+  class ChatterLogger
+    def initialize
+      @file_name = "logs/telegram_chatgpt.log"
+      @log_file = File.open("logs/telegram_chatgpt.log", "a")
+    end
+
+    attr_reader :log_file
+
+    def log(message)
+      log_file.puts(message)
+      system "echo '#{message}'"
+    end
+  end
+end

data/lib/chatgpt_assistant/config.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_model"
+require_relative "migrations"
+require "fileutils"
+
+module ChatgptAssistant
+  # This class is responsible for the configuration of the Chatgpt Assistant
+  class Config
+    def initialize
+      @env_type = ENV["ENV_TYPE"]
+      @language = ENV["LANGUAGE"]
+      @mode = ENV["MODE"]
+      @database_host = ENV["POSTGRES_HOST"]
+      @database_name = ENV["POSTGRES_DB"]
+      @database_username = ENV["POSTGRES_USER"]
+      @database_password = ENV["POSTGRES_PASSWORD"]
+      @openai_api_key = ENV["OPENAI_API_KEY"]
+      @telegram_token = ENV["TELEGRAM_TOKEN"]
+      @discord_token = ENV["DISCORD_TOKEN"]
+      @discord_client_id = ENV["DISCORD_CLIENT_ID"]
+      @ibm_api_key = ENV["IBM_API_KEY"]
+      @ibm_url = ENV["IBM_URL"]
+      @aws_access_key_id = ENV["AWS_ACCESS_KEY_ID"]
+      @aws_secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
+      @aws_region = ENV["AWS_REGION"]
+      @discord_prefix = ENV["DISCORD_PREFIX"]
+    end
+
+    attr_reader :openai_api_key, :telegram_token, :discord_token, :ibm_api_key, :ibm_url,
+                :aws_access_key_id, :aws_secret_access_key, :aws_region, :mode, :language,
+                :discord_client_id, :discord_public_key, :env_type, :discord_prefix
+
+    def db_connection
+      ActiveRecord::Base.establish_connection(
+        adapter: "postgresql",
+        host: database_host,
+        port: 5432,
+        database: database_name,
+        username: database_username,
+        password: database_password
+      )
+      ActiveRecord::Base.logger = Logger.new($stdout) if ENV["ENV_TYPE"] == "development"
+    end
+
+    def migrate
+      db_connection
+      ActiveRecord::Base.logger = Logger.new($stdout)
+      UserMigration.new.migrate(:up)
+      ChatMigration.new.migrate(:up)
+      MessageMigration.new.migrate(:up)
+    end
+
+    private
+
+    attr_reader :database_host, :database_name, :database_username, :database_password
+  end
+end