chatgpt_assistant 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfdbae4dc34427a795f312216602a7a7efd52511b39ab5e81a6d87211bf99e1b
-  data.tar.gz: 3292735303abbad74ff7cd65c0889b8c2939ba66113ed738b7b601829fc1871b
+  metadata.gz: c735d019dd75e4679918ae36b75d61978f78cf4b7ca11c8530915cc738cb7ec6
+  data.tar.gz: 73bdda5095040e37e3bb270c287ec8549fe156749a35b28ecca592c5205b17c9
 SHA512:
-  metadata.gz: 5f86bbc67fef4385c13db8377bf9eb1208bc43950afbfabe5e7f5af5a706ebdce90e185aacde659c1d0f210b50cb20cbd847391f1ef59c85c5ea9e76102345dc
-  data.tar.gz: cb96f57300a0c5aaa183df1acbfc116c7bc03c95868a275832c30b0ac6e52702bae8b9b06a4ad9160a08d14e8b80da97d61b3178189755629ff5998825fe8077
+  metadata.gz: 5ebf7e87f62c820eb5988dfe6a0635d385a2329bdb7b690e5ee15bac182ab162f8e502b111d14fb4c66aa6923a702e57b7f8ae5fef351582ff5b1a9a1bd7bf8f
+  data.tar.gz: 78367d4df7a05b0290889fb854a925abd239b277e8fe9f7236db9c6715405c989f40ed0d732c0db05e3abd6e63c70099c96317fe5f3c13213f53aa26d5cf84f8

data/.env_prod_sample

@@ -3,7 +3,7 @@ LANGUAGE=en # or pt currently
 MODE=aws # or ibm
 DISCORD_PREFIX=gpt!
 
-POSTGRES_DB=telegram_chatgpt_development # or your database
+POSTGRES_DB=chatgpt_assistant_production # or your database
 POSTGRES_USER=postgres # or your user
 POSTGRES_PASSWORD=postgres # or your password
 

data/.env_sample

@@ -3,7 +3,7 @@ LANGUAGE=en # or pt currently
 MODE=aws # or ibm
 DISCORD_PREFIX=dgpt!
 
-POSTGRES_DB=telegram_chatgpt_development # or your database
+POSTGRES_DB=chatgpt_assistant_development # or your database
 POSTGRES_USER=postgres # or your user
 POSTGRES_PASSWORD=postgres # or your password
 

data/.rubocop.yml

@@ -12,15 +12,26 @@ Style/StringLiteralsInInterpolation:
 Layout/LineLength:
   Max: 160
 
-# remove code length limit
+Metrics/ModuleLength:
+  Max: 120
+
 Metrics/MethodLength:
   Max: 200
 
-# Metrics/BlockLength:
-#   Enabled: false
+Metrics/BlockLength:
+  Max: 200
 
 Metrics/ClassLength:
-  Enabled: false
+  Max: 300
 
 Metrics/AbcSize:
-  Max: 40
+  Max: 35
+
+Layout/AccessModifierIndentation:
+  EnforcedStyle: indent
+  
+Layout/IndentationWidth:
+  Width: 2
+
+Layout/IndentationConsistency:
+  EnforcedStyle: indented_internal_methods

data/Dockerfile

@@ -5,11 +5,8 @@ COPY Gemfile /chatgpt_assistant/Gemfile
 COPY Gemfile.lock /chatgpt_assistant/Gemfile.lock
 RUN bundle install
 
-# Opus Installation for voice messages
-
 RUN apt-get install -y wget
 RUN wget https://archive.mozilla.org/pub/opus/opus-1.3.1.tar.gz
 RUN tar -xvf opus-1.3.1.tar.gz
 RUN cd opus-1.3.1 && ./configure && make && make install
-RUN rm -rf opus-1.3.1.tar.gz opus-1.3.1
-
+RUN rm -rf opus-1.3.1.tar.gz opus-1.3.1

data/README.md

@@ -86,17 +86,20 @@ After starting the Docker Compose services, you can use the features of the gem
 
 ## Discord Bot Commands
 
-- !start - shows the welcome message
-- !help - shows the help message
-- !login email:password - logs in the user
-- !register email:password - registers a new user
-- !list - lists the user created chatbots
-- !sl_chat CHAT TITLE - starts a chat with the chatbot with the given title
-- !new_chat CHAT TITLE - creates a new chatbot with the given title
-- !ask TEXT - sends a text to the chatbot
-- !connect - connects the chat bot to the current channel
-- !disconnect - disconnects the chat bot from the current channel
-- !speak TEXT - sends a text to the chatbot and gets the response in voice
+The discord commands prefix can be changed in the .env file.
+The default prefix is dgpt!
+
+- dgpt!start - shows the welcome message
+- dgpt!help - shows the help message
+- dgpt!login email:password - logs in the user
+- dgpt!register email:password - registers a new user
+- dgpt!list - lists the user created chatbots
+- dgpt!sl_chat CHAT TITLE - starts a chat with the chatbot with the given title
+- dgpt!new_chat CHAT TITLE - creates a new chatbot with the given title
+- dgpt!ask TEXT - sends a text to the chatbot
+- dgpt!connect - connects the chat bot to the current channel
+- dgpt!disconnect - disconnects the chat bot from the current channel
+- dgpt!speak TEXT - sends a text to the chatbot and gets the response in voice
 
 ## Telegram Bot Commands
 

data/exe/chatgpt_assistant

@@ -31,7 +31,7 @@ end
 end
 
 %w[deploy_and_build.sh deploy.sh].each do |file|
-  `cp #{gem_dir}/bin/#{file} #{path}`
+  `cp #{gem_dir}/#{file} #{path}`
 end
 
 %w[/.bundle/ /.yardoc /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ /db_data /db_data/*
@@ -42,7 +42,7 @@ end
 `cd #{path} && git init`
 
 `mkdir -p #{path}/.github/workflows`
-`cp #{gem_dir}/.github/workflows/*.yml #{path}/.github/workflows`
+`cp #{gem_dir}/workflows/*.yml #{path}/.github/workflows`
 
 puts "Done! Now you can run 'cd #{path} && bundle install'"
 puts "Build the docker image with 'rake compose:build'"

data/lib/bots/application_bot.rb

@@ -1,8 +1,25 @@
 # frozen_string_literal: true
 
+require_relative "helpers/messenger_helper"
+require_relative "helpers/authentication_helper"
+require_relative "helpers/visit_helper"
+require_relative "helpers/audio_helper"
+require_relative "helpers/logger_action_helper"
+require_relative "helpers/search_helper"
+require_relative "helpers/validation_helper"
+require_relative "helpers/file_helper"
 module ChatgptAssistant
   # This class is responsible to contain the shared variables between the bot classes
   class ApplicationBot
+    include MessengerHelper
+    include AuthenticationHelper
+    include VisitHelper
+    include AudioHelper
+    include LoggerActionHelper
+    include SearchHelper
+    include ValidationHelper
+    include FileHelper
+
     def initialize(config)
       @config = config
       default_msg = DefaultMessages.new(@config.language)
@@ -19,100 +36,14 @@ module ChatgptAssistant
       @help_messages = default_msg.help_messages
     end
 
-    def chatter
-      @chatter ||= Chatter.new(openai_api_key)
-    end
-
-    def audio_recognition
-      @audio_recognition ||= AudioRecognition.new(openai_api_key)
-    end
-
-    def audio_synthesis
-      @audio_synthesis ||= AudioSynthesis.new(config)
-    end
-
-    def transcribed_text
-      audio_recognition.transcribe_audio(audio_url)
-    end
-
-    def find_useremail(email)
-      User.find_by(email: email)
-    end
-
-    def find_userdiscord(discord_id)
-      User.find_by(discord_id: discord_id)
-    end
-
-    def find_usertelegram(telegram_id)
-      User.find_by(telegram_id: telegram_id)
-    end
-
-    def valid_password?(user, password)
-      return false if password.nil?
-
-      salt = user.password_salt
-      password_hash = user.password_hash
-
-      BCrypt::Engine.hash_secret(password, salt) == password_hash
-    end
-
-    def auth_userdiscord(email, password, discord_id)
-      user = find_useremail(email)
-      return "user not found" unless user
-      return "wrong password" if password.nil?
-
-      valid_password?(user, password) ? user_disc_access(discord_id, user.email) : "wrong password"
-    end
-
-    def user_disc_access(discord_id, user_email)
-      last_access = find_userdiscord(discord_id)
-      new_access = find_useremail(user_email)
-      last_acess.update(discord_id: nil) if last_access && (last_access != new_access)
-      new_access.update(discord_id: discord_id)
-      new_access
-    end
-
-    def discord_user_create(discord_id, email, password, name)
-      user = User.new(discord_id: discord_id, email: email, password_hash: password, name: name)
-      last_access = find_userdiscord(discord_id)
-      last_access&.update(discord_id: nil)
-      user.save
-    end
-
-    def auth_usertelegram(email, password, telegram_id)
-      user = find_useremail(email)
-      return "user not found" unless user
-      return "wrong password" if password.nil?
-
-      valid_password?(user, password) ? user_tele_access(telegram_id, user.email) : "wrong password"
-    end
-
-    def user_tele_access(telegram_id, user_email)
-      last_access = find_usertelegram(telegram_id)
-      new_access = find_useremail(user_email)
-      last_acess.update(telegram_id: nil) if last_access && (last_access != new_access)
-      new_access.update(telegram_id: telegram_id)
-      new_access
-    end
-
-    def telegram_user_create(telegram_id, email, password, name)
-      user = User.new(telegram_id: telegram_id, email: email, password_hash: password, name: name)
-      last_access = find_usertelegram(telegram_id)
-      last_access&.update(telegram_id: nil)
-      user.save
-    end
-
-    def delete_all_voice_files
-      Dir.glob("voice/*").each do |file|
-        next if [".keep", "voice/.keep"].include?(file)
-
-        File.delete(file)
-      end
-    end
-
     attr_reader :openai_api_key, :telegram_token, :database, :default_msg,
                 :mode, :config, :discord_token, :discord_client_id,
                 :discord_prefix, :commom_messages, :error_messages, :success_messages,
                 :help_messages
+    attr_accessor :msg, :evnt, :bot, :audio_url, :visitor, :user, :chat, :chat_id
+
+    def chatter
+      @chatter ||= Chatter.new(openai_api_key)
+    end
   end
 end

data/lib/bots/discord_bot.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "helpers/discord_helper"
+require_relative "helpers/discord_voice_helper"
+
 module ChatgptAssistant
   # This class is responsible to handle the discord bot
   class DiscordBot < ApplicationBot
@@ -21,274 +24,132 @@ module ChatgptAssistant
 
     private
 
-    attr_reader :message
-    attr_accessor :evnt, :user, :chats, :chat
+      include DiscordHelper
+      include DiscordVoiceHelper
 
-    def bot
-      @bot ||= Discordrb::Commands::CommandBot.new(
-        token: discord_token,
-        client_id: discord_client_id,
-        prefix: discord_prefix
-      )
-    end
+      attr_reader :message
+      attr_accessor :evnt, :user, :chats, :chat
 
-    def start_event
-      bot.command :start do |event|
-        @evnt = event
-        @user = event.user
-        start_action
+      def start_event
+        bot.command :start do |event|
+          @evnt = event
+          @user = event.user
+          start_action
+        end
       end
-    end
-
-    def start_action
-      evnt.respond commom_messages[:start_helper].gsub("register/", "gpt!register ")
-      evnt.respond commom_messages[:start_sec_helper].gsub("login/", "gpt!login ")
-    end
 
-    def login_event
-      bot.command :login do |event|
-        @message = event.message.content.split(" ")[1]
-        @evnt = event
-        message.nil? ? event.respond(commom_messages[:login]) : login_action
+      def login_event
+        bot.command :login do |event|
+          @message = event.message.content.split(" ")[1]
+          @evnt = event
+          message.nil? ? event.respond(commom_messages[:login]) : login_action
+        end
       end
-    end
 
-    def login_action
-      user_email = message.split(":")[0]
-      user_password = message.split(":")[1]
-      case auth_userdiscord(user_email, user_password, evnt.user.id)
-      when "user not found"
-        evnt.respond error_messages[:user_not_found]
-      when "wrong password"
-        evnt.respond error_messages[:wrong_password]
-      when find_useremail(user_email)
-        evnt.respond success_messages[:user_logged_in]
+      def register_event
+        bot.command :register do |event|
+          @message = event.message.content.split(" ")[1]
+          @evnt = event
+          message.nil? ? event.respond(commom_messages[:register]) : register_action
+        end
       end
-    end
 
-    def register_event
-      bot.command :register do |event|
-        @message = event.message.content.split(" ")[1]
-        @evnt = event
-        message.nil? ? event.respond(commom_messages[:register]) : register_action
+      def list_event
+        bot.command :list do |event|
+          @evnt = event
+          @user = find_user(discord_id: event.user.id)
+          event.respond error_messages[:user_not_logged_in] if user.nil?
+          event.respond error_messages[:chat_not_found] if user.chats.empty? && user
+          list_action if user && !user.chats.empty?
+        end
       end
-    end
-
-    def register_action
-      user_email = message.split(":")[0]
-      user_password = message.split(":")[1]
-      find_useremail(user_email).nil? ? create_user_action(user_email, user_password) : evnt.respond(error_messages[:user_already_exists])
-    end
-
-    def create_user_action(mail, pass)
-      id = evnt.user.id
-      name = evnt.user.username
-      discord_user_create(id, mail, pass, name) ? evnt.respond(success_messages[:user_created]) : evnt.respond(error_messages[:user_not_created])
-    end
-
-    def list_event
-      bot.command :list do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        event.respond error_messages[:chat_not_found] if user.chats.empty? && user
-        list_action if user && !user.chats.empty?
-      end
-    end
 
-    def list_action
-      chats_title = chats.map(&:title)
-      evnt.respond commom_messages[:chat_list]
-      evnt.respond chats_title.join("\n")
-    end
-
-    def hist_event
-      bot.command :hist do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        title = event.message.content.split(" ")[1..].join(" ")
-        @chat = user.chat_by_title(title)
-        event.respond error_messages[:chat_not_found] if chat.nil? && user
-        hist_action if user && chat
+      def hist_event
+        bot.command :hist do |event|
+          @evnt = event
+          event.respond error_messages[:user_not_logged_in] if user.nil?
+          title = event.message.content.split(" ")[1..].join(" ")
+          @chat = user.chat_by_title(title)
+          event.respond error_messages[:chat_not_found] if chat.nil? && user
+          hist_action if user && chat
+        end
       end
-    end
 
-    def hist_action
-      messages = Message.where(chat_id: chat.id).order(:created_at)
-      messages.each do |message|
-        evnt.respond "#{message.role} - #{message.content}\n#{message.created_at.strftime("%d/%m/%Y %H:%M")}"
+      def help_event
+        bot.command :help do |event|
+          @evnt = event
+          help_action
+        end
       end
-      "This is the end of the chat history"
-    end
 
-    def help_event
-      bot.command :help do |event|
-        @evnt = event
-        help_action
+      def new_chat_event
+        bot.command :new_chat do |event|
+          @evnt = event
+          @user = find_user(discord_id: event.user.id)
+          event.respond error_messages[:user_not_logged_in] if user.nil?
+          create_chat_action if user
+        end
       end
-    end
 
-    def help_action
-      message = help_messages.join("\n").gsub(" /", discord_prefix)
-                             .gsub("register/", "#{discord_prefix}register ")
-                             .gsub("login/", "#{discord_prefix}login ")
-                             .gsub("new_chat/", "#{discord_prefix}new_chat/")
-                             .gsub("sl_chat/", "#{discord_prefix}sl_chat/")
-      evnt.respond message
-    end
+      def sl_chat_event
+        bot.command :sl_chat do |event|
+          @evnt = event
+          chat_to_select = event.message.content.split(" ")[1..].join(" ")
+          @user = find_user(discord_id: event.user.id)
+          event.respond error_messages[:user_not_logged_in] if user.nil?
 
-    def new_chat_event
-      bot.command :new_chat do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        create_chat_action if user
+          sl_chat_action(chat_to_select) if user
+        end
       end
-    end
 
-    def create_chat_action
-      chat_title = event.message.content.split(" ")[1..].join(" ")
-      chat = Chat.new(user_id: user.id, title: chat_title, status: 0)
-      chat.save ? respond_with_success : evnt.respond(error_messages[:chat_creation])
-    end
-
-    def respond_with_success
-      user.update(current_chat_id: chat.id)
-      evnt.respond success_messages[:chat_created]
-    end
-
-    def sl_chat_event
-      bot.command :sl_chat do |event|
-        @evnt = event
-        chat_to_select = event.message.content.split(" ")[1..].join(" ")
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-
-        sl_chat_action(chat_to_select) if user
+      def ask_event
+        bot.command :ask do |event|
+          @evnt = event
+          @message = event.message.content.split(" ")[1..].join(" ")
+          @user = find_user(discord_id: event.user.id)
+          event.respond error_messages[:user_not_logged_in] if user.nil?
+          ask_action if user
+        end
       end
-    end
-
-    def sl_chat_action(chat_to_select)
-      @chat = user.chat_by_title(chat_to_select)
-      evnt.respond error_messages[:chat_not_found] if chat.nil?
-      user.update(current_chat_id: chat.id) if chat
-      evnt.respond success_messages[:chat_selected] if chat
-    end
 
-    def ask_event
-      bot.command :ask do |event|
-        @evnt = event
-        @message = event.message.content.split(" ")[1..].join(" ")
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        ask_action if user
+      def voice_connect_event
+        bot.command :connect do |event|
+          @evnt = event
+          @user = find_user(discord_id: event.user.id)
+          @chat = Chat.where(id: user.current_chat_id).last
+          voice_connect_checker_action
+          voice_connection_checker_action
+          discord_voice_bot_connect
+        end
       end
-    end
-
-    def ask_action
-      @chat = Chat.where(id: user.current_chat_id).last
-      evnt.respond error_messages[:chat_not_found] if chat.nil?
-      @message = Message.new(chat_id: chat.id, content: message, role: "user") if chat
-      (message.save ? answer_action : evnt.respond(error_messages[:message_not_saved])) if chat
-    end
-
-    def answer_action
-      response = chatter.chat(message.content, chat.id)
-      evnt.respond response
-    end
 
-    def voice_connect_event
-      bot.command :connect do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        @chat = Chat.where(id: user.current_chat_id).last
-        voice_connect_checker_action
-        voice_connection_checker_action
-        bot.voice_connect(event.user.voice_channel) if bot_disconnected?
-        bot_connected? ? "Connected to voice channel" : "Error connecting to voice channel"
+      def disconnect_event
+        bot.command :disconnect do |event|
+          @evnt = event
+          @user = find_user(discord_id: event.user.id)
+          disconnect_checker_action
+          disconnect_action if user && event.user.voice_channel && event.voice
+        end
       end
-    end
-
-    def voice_connect_checker_action
-      evnt.respond error_messages[:user_not_logged_in] if user.nil?
-      evnt.respond error_messages[:chat_not_found] if user && chat.nil?
-    end
 
-    def voice_connection_checker_action
-      evnt.respond error_messages[:user_not_in_voice_channel] if event.user.voice_channel.nil? && user
-      evnt.respond error_messages[:bot_already_connected] if event.voice && user
-    end
-
-    def bot_disconnected?
-      user && evnt.user.voice_channel && !evnt.voice && !chat.nil?
-    end
-
-    def bot_connected?
-      user && evnt.user.voice_channel && evnt.voice && !chat.nil?
-    end
-
-    def disconnect_event
-      bot.command :disconnect do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        disconnect_checker_action
-        disconnect_action if user && event.user.voice_channel && event.voice
+      def speak_event
+        bot.command :speak do |event|
+          @evnt = event
+          @message = event.message.content.split(" ")[1..].join(" ")
+          @user = find_user(discord_id: event.user.id)
+          @chat = user.current_chat
+          speak_connect_checker_action
+          speak_connection_checker_action
+          ask_to_speak_action if user && event.user.voice_channel && event.voice && !chat.nil?
+        end
       end
-    end
 
-    def disconnect_checker_action
-      evnt.respond error_messages[:user_not_logged_in] if user.nil?
-      evnt.respond error_messages[:user_not_in_voice_channel] if event.user.voice_channel.nil? && user
-      evnt.respond error_messages[:user_not_connected] if !event.voice && user
-    end
-
-    def disconnect_action
-      bot.voice_destroy(event.user.voice_channel)
-      "Disconnected from voice channel"
-    end
-
-    def speak_event
-      bot.command :speak do |event|
-        @evnt = event
-        @message = event.message.content.split(" ")[1..].join(" ")
-        @user = find_userdiscord(event.user.id)
-        @chat = user.current_chat
-        speak_connect_checker_action
-        speak_connection_checker_action
-        ask_to_speak_action if user && event.user.voice_channel && event.voice && !chat.nil?
+      def bot_init
+        at_exit { bot.stop }
+        bot.run
+      rescue StandardError => e
+        Error.create(message: e.message, backtrace: e.backtrace)
+        retry
       end
-    end
-
-    def speak_connect_checker_action
-      evnt.respond error_messages[:user_not_logged_in] if user.nil?
-      evnt.respond error_messages[:chat_not_found] if user && event.user.voice_channel && event.voice && chat.nil?
-    end
-
-    def speak_connection_checker_action
-      evnt.respond error_messages[:user_not_in_voice_channel] if event.user.voice_channel.nil? && user
-      evnt.respond error_messages[:bot_not_in_voice_channel] if !event.voice && user
-    end
-
-    def ask_to_speak_action
-      Message.create(chat_id: chat.id, content: message, role: "user")
-      response = chatter.chat(message, chat.id)
-      audio_path = audio_synthesis.synthesize_text(response)
-      speak_answer_action(audio_path, response)
-    end
-
-    def speak_answer_action(audio_path, response)
-      evnt.respond response
-      evnt.voice.play_file(audio_path)
-      delete_all_voice_files
-      "OK"
-    end
-
-    def bot_init
-      at_exit { bot.stop }
-      bot.run
-    rescue StandardError
-      start
-    end
   end
 end

data/lib/bots/helpers/audio_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for audio
+  module AudioHelper
+    def recognition
+      @recognition ||= AudioRecognition.new(openai_api_key)
+    end
+
+    def synthesis
+      @synthesis ||= AudioSynthesis.new(config)
+    end
+
+    def transcribe_file(url)
+      recognition.transcribe_audio(url)
+    end
+  end
+end