open_ai_bot 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb356e64b39be0d26d67b951fb369bfbe73f7ef75dbd1b7713ef34a69c609702
-  data.tar.gz: 6bd88aac60d93d779722799e96e583d876e34c352c07dca7ede1e0d5cd77dcbe
+  metadata.gz: 269af8f1a7f00af420ae1dfc7abc7f819dd145c9b3d63c757c0b40422c5391a1
+  data.tar.gz: 3befe567139afa676bdda80bfe153a9d56b6125d8bf284da496b376b08ecebbd
 SHA512:
-  metadata.gz: 1db16f7ad18c4b4f1418aefd245f40fd125bc3cc12e73b4bd90fbedafdbdc5280fc2ce4591049e0fdb1bd208b83301b2ff60bc25459c9f10181e465a31d3b2c3
-  data.tar.gz: '097d28aa7788ae0d33a41c8213de556ddf8a01f7ba07e965ae57093bcca134105cdb64546ffa34ab0d5ede6a59602c45a49ddbadb785eaab8371cb0dec552bcb'
+  metadata.gz: 3c0b64fed5c62342bea3d5f9a1a8d129e5929184d17f50c90ccd610eda03377a955bd294ac8b54d960df05a6b170d31b06c52dd2fd517e60a8b3f7d278b47745
+  data.tar.gz: 1bcb5a576fbcc634e08c52db97d0fbed5283f24963b7174157841f925dd77df43d4c2a6422a4ce0bf6779f18333cc991a821c4f0828618bb651ba3ef952a9f02

data/README.md

@@ -1,4 +1,11 @@
 # OpenAI Telegram bot
+## What it does
+- ChatGPT
+  Send any message to the bot, or ping its @username or reply ot its message in a group chat. It will forward your message to ChatGPT and return a response, keeping track of context.
+- Whisper
+  Record a voice message in any chat with the bot or reply to a forwarded message with the `/transcribe` command. It will reply with a transcript, automatically detecting language(s).
+- DALL-e
+  Send `/dalle {prompt/description}` command. The bot will reply with a picture based on your prompt.
 
 ## Dependencies
 1. Ruby (`ruby -v` should return something, preferrably > 3.2)

data/lib/ext/blank.rb

@@ -0,0 +1,27 @@
+Object.class_eval do
+  def blank?
+    false
+  end
+
+  def present?
+    !blank?
+  end
+end
+
+NilClass.class_eval do
+  def blank?
+    true
+  end
+end
+
+String.class_eval do
+  def blank?
+    gsub(/\s/, '').empty?
+  end
+end
+
+Enumerable.module_eval do
+  def blank?
+    size == 0
+  end
+end

data/lib/ext/in.rb

@@ -0,0 +1,5 @@
+Object.class_eval do
+  def in?(collection)
+    collection.include?(self)
+  end
+end

data/lib/open_ai/chat_gpt.rb

@@ -1,97 +1,120 @@
 # frozen_string_literal: true
 
-module ChatGPT
-  module ClassMethods
-    def threads
-      @threads ||= {}
-    end
+module OpenAI
+  module ChatGPT
+    module ClassMethods
+      def threads
+        @threads ||= {}
+      end
 
-    def new_thread(chat_id)
-      new_thread = ChatThread.new(initial_messages)
-      threads[chat_id] = new_thread
-    end
+      def new_thread(chat_id)
+        new_thread = ChatThread.new(initial_messages)
+        threads[chat_id] = new_thread
+      end
 
-    def default_instruction
-      <<~MSG
-        You are in a group chat. In the first line of the message, you will receive the name of the user who sent that message.
-        Different languages can be used.
-        You don't have to sign your messages this way or use users' names without need.
-      MSG
-    end
+      def default_instruction
+        msg = <<~MSG
+          You are in a group chat. In the first line of the message, you will receive the name of the user who sent that message.
+          Do not sign your messages this way
+          Do not use users' names without need (for example, if you are replying to @foo, do not add "@foo" to your message)
+          You can still use names to mention other users you're not replying to directly.
 
-    def first_user_message
-      <<~MSG
-        <@tyradee>:
-        I drank some tea today.
-      MSG
-    end
+          Different languages can be used.
+        MSG
 
-    def first_bot_message
-      <<~MSG
-        Good for you!
-      MSG
-    end
+        SystemMessage.new(
+          body: msg
+        )
+      end
 
-    def initial_messages
-      [
-        { role: :system, content: default_instruction },
-        { role: :user, content: first_user_message },
-        { role: :assistant, content: first_bot_message }
-      ]
-    end
-  end
+      def first_user_message
+        Message.new(
+          from: "@tyradee",
+          body: "I drank some tea today."
+        )
+      end
 
-  def self.included(base)
-    base.extend ClassMethods
-  end
+      def first_bot_message
+        BotMessage.new(
+          body: "Good for you!"
+        )
+      end
 
-  def init_session
-    self.class.new_thread(@chat.id)
-    send_message(session_restart_message)
-  end
+      def initial_messages
+        [
+          default_instruction,
+          first_user_message,
+          first_bot_message
+        ]
+      end
+    end
 
-  def handle_gpt_command
-    return unless bot_mentioned? || bot_replied_to? || private_chat?
-    return if self.class.registered_commands.keys.any? { @text.match? Regexp.new(_1) }
+    def self.included(base)
+      base.extend ClassMethods
+    end
 
-    if !allowed_chat?
-      reply(chat_not_allowed_message, parse_mode: "Markdown") if chat_not_allowed_message
-      return
+    def init_session
+      self.class.new_thread(@chat.id)
+      send_message(session_restart_message)
     end
 
-    # Find the ChatThread current message belongs to (or create a fresh new one)
-    @thread = self.class.threads[@chat.id] || self.class.new_thread(@chat.id)
+    def current_thread
+      self.class.threads[@chat.id] || self.class.new_thread(@chat.id)
+    end
 
-    # `text` is whatever the current user wrote, except the bot username (unless it's only whitespace)
-    text = @text_without_bot_mentions
-    text = nil if text.gsub(/\s/, "").empty?
+    def username(user)
+      return unless user
+      return "@" + user.username if user.username.present?
+      return user.first_name if user.first_name.present?
 
-    # `target_text` is the text of the message current user replies to
-    target_text = @replies_to&.text || @replies_to&.caption
-    target_text = nil if @target&.username == config.bot_username
+      "NULL"
+    end
 
+    def handle_gpt_command
+      return unless bot_mentioned? || bot_replied_to? || private_chat?
+      return if self.class.registered_commands.keys.any? { @text.include? _1 }
 
-    name = "@#{@user.username}"
-    target_name = "@#{@replies_to&.from&.username}"
+      if !allowed_chat?
+        reply(chat_not_allowed_message, parse_mode: "Markdown") if chat_not_allowed_message
+        return
+      end
 
-    # If present, glue together current user text and reply target text, marking them with usernames
-    text = [
-      add_name(target_name, target_text),
-      add_name(name, text)
-    ].join("\n\n").strip
+      current_message = Message.new(
+        id: @message_id,
+        replies_to: @replies_to&.message_id,
+        from: username(@user),
+        body: @text_without_bot_mentions,
+        chat_id: @chat.id
+      )
 
-    @thread.add!(:user, text)
-    send_request
-  end
+      return unless current_message.valid?
+
+      replies_to =
+        if @replies_to && !bot_replied_to?
+          Message.new(
+            id: @replies_to.message_id,
+            replies_to: @replies_to.reply_to_message&.message_id,
+            from: username(@target),
+            body: @replies_to.text.to_s.gsub(/@#{config.bot_username}\b/, ""),
+            chat_id: @chat.id
+          )
+        else
+          nil
+        end
+
+      current_thread.add(replies_to)
+      current_thread.add(current_message)
+
+      send_request!
+    end
 
-  def send_request
-    attempt(3) do
+    def send_request!
       send_chat_action(:typing)
 
       response = open_ai.chat(
         parameters: {
           model: config.open_ai["chat_gpt_model"],
-          messages: @thread.history
+          messages: current_thread.as_json
         }
       )
 
@@ -101,25 +124,26 @@ module ChatGPT
         send_chat_gpt_error(error_text.strip)
       else
         text = response.dig("choices", 0, "message", "content")
-        puts "#{Time.now.utc} | Chat ID: #{@chat.id}, tokens used: #{response.dig("usage", "total_tokens")}"
+        tokens = response.dig("usage", "total_tokens")
 
-        send_chat_gpt_response(text)
+        send_chat_gpt_response(text, tokens)
       end
     end
-  end
 
-  def send_chat_gpt_error(text)
-    reply(text, parse_mode: "Markdown")
-  end
-
-  def send_chat_gpt_response(text)
-    reply(text)
-    @thread.add!(:assistant, text)
-  end
-
-  def add_name(name, text)
-    return "" if text.nil? || text.empty?
+    def send_chat_gpt_error(text)
+      reply(text, parse_mode: "Markdown")
+    end
 
-    "<#{name}>:\n#{text}"
+    def send_chat_gpt_response(text, tokens)
+      id = reply(text).dig("result", "message_id")
+      bot_message = BotMessage.new(
+        id: id,
+        replies_to: @message_id,
+        body: text,
+        chat_id: @chat.id,
+        tokens: tokens
+      )
+      current_thread.add(bot_message)
+    end
   end
 end

data/lib/open_ai/chat_thread.rb

@@ -1,17 +1,26 @@
 # frozen_string_literal: true
 
-class ChatThread
-  def initialize(defaults = [])
-    @history = defaults
-    puts @history
-  end
+module OpenAI
+  class ChatThread
+    def initialize(defaults = [])
+      @history ||= defaults
+      puts @history
+    end
+
+    attr_reader :history
+
+    def add(message)
+      return false unless message&.valid?
+      return false if @history.any? { message.id == _1.id}
 
-  attr_reader :history
+      @history << message
+      puts message
 
-  def add!(role, content)
-    return if [role, content].any? { [nil, ""].include?(_1) }
+      true
+    end
 
-    puts content
-    @history.push({ role: role, content: content.gsub(/\\xD\d/, "") })
+    def as_json
+      @history.map(&:as_json)
+    end
   end
 end

data/lib/open_ai/dalle.rb

@@ -1,27 +1,29 @@
 # frozen_string_literal: true
 
-module Dalle
-  def dalle
-    return unless allowed_chat?
+module OpenAI
+  module Dalle
+    def dalle
+      return unless allowed_chat?
 
-    attempt(3) do
-      puts "Received a /dalle command"
-      prompt = @replies_to&.text || @text_without_command
-      send_chat_action(:upload_photo)
+      attempt(3) do
+        puts "Received a /dalle command"
+        prompt = @replies_to&.text || @text_without_command
+        send_chat_action(:upload_photo)
 
-      puts "Sending request"
-      response = open_ai.images.generate(parameters: { prompt: prompt })
+        puts "Sending request"
+        response = open_ai.images.generate(parameters: { prompt: prompt })
 
-      send_chat_action(:upload_photo)
+        send_chat_action(:upload_photo)
 
-      url = response.dig("data", 0, "url")
+        url = response.dig("data", 0, "url")
 
-      puts "DALL-E finished, sending photo to Telegram..."
+        puts "DALL-E finished, sending photo to Telegram..."
 
-      if response["error"]
-        reply_code(response)
-      else
-        send_photo(url, reply_to_message_id: @msg.message_id)
+        if response["error"]
+          reply_code(response)
+        else
+          send_photo(url, reply_to_message_id: @msg.message_id)
+        end
       end
     end
   end

data/lib/open_ai/message.rb

@@ -0,0 +1,68 @@
+module OpenAI
+  # An over-engineered solution that ultimately wasn't used for its intent.
+  # (ChatGPT isn't brilliant at parsing JSON sructures without starting to reply in JSON, so most of it is useless)
+
+  class Message
+    attr_accessor :body, :from, :id, :replies_to, :tokens, :chat_id
+    attr_reader :role
+
+    def initialize(**kwargs)
+      kwargs.each_pair { public_send("#{_1}=", _2) }
+      @role = :user
+    end
+
+    def valid?
+      [body, from, id, chat_id].all?(&:present?)
+    end
+
+    # Format for OpenAI API
+    def as_json
+      content = [from, body].join("\n")
+      { role:, content: content }
+    end
+
+    # Format for human-readable logs
+    def to_s
+      msg_lines = {
+        "Chat ID" => chat_id,
+        "Message ID" => id,
+        "From" => from,
+        "To" => replies_to,
+        "Body" => body,
+        "Tokens used" => tokens
+      }.reject { |_k, v|
+        v.blank?
+      }.map { |k, v|
+        "#{k}: #{v}"
+      }
+
+      [Time.now.utc, *msg_lines].join("\n") + "\n\n"
+    end
+  end
+
+  class SystemMessage < Message
+    def initialize(...)
+      super(...)
+      @role = :system
+    end
+
+    def to_s
+      [Time.now.utc, "SYSTEM INSTRUCTION", body].join("\n") + "\n"
+    end
+
+    def valid?
+      body.present?
+    end
+  end
+
+  class BotMessage < Message
+    def initialize(...)
+      super(...)
+      @role = :assistant
+    end
+
+    def valid?
+      [body, id, chat_id, tokens].all?(&:present?)
+    end
+  end
+end

data/lib/open_ai/utils.rb

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
 
-module Utils
-  def attempt(times, exception=Net::ReadTimeout)
-    retries ||= 0
-    yield
-  rescue exception => e
-    retries += 1
-    if retries < times
-      retry
-    else
-      reply(e.message, parse_mode: "Markdown")
+module OpenAI
+  module Utils
+    def attempt(times, exception=Net::ReadTimeout)
+      retries ||= 0
+      yield
+    rescue exception => e
+      retries += 1
+      if retries < times
+        retry
+      else
+        reply(e.message, parse_mode: "Markdown")
+      end
     end
-  end
 
-  def download_file(voice)
-    file_path = @api.get_file(file_id: voice.file_id)["result"]["file_path"]
+    def download_file(voice)
+      file_path = @api.get_file(file_id: voice.file_id)["result"]["file_path"]
 
-    url = "https://api.telegram.org/file/bot#{config.token}/#{file_path}"
+      url = "https://api.telegram.org/file/bot#{config.token}/#{file_path}"
 
-    file = Down.download(url)
-    FileUtils.mv(file.path, "./#{file.original_filename}")
-    file
+      file = Down.download(url)
+      FileUtils.mv(file.path, "./#{file.original_filename}")
+      file
+    end
   end
 end

data/lib/open_ai/whisper.rb

@@ -1,61 +1,63 @@
 # frozen_string_literal: true
 
-module Whisper
-  def transcribe
-    if !allowed_chat?
-      if @command == "/transcribe"
-        reply(chat_not_allowed_message) if chat_not_allowed_message
-      end
-
-      return
-    end
-
-    attempt(3) do
-      voice =
+module OpenAI
+  module Whisper
+    def transcribe
+      if !allowed_chat?
         if @command == "/transcribe"
-          @replies_to&.voice
-        else
-          @msg.voice
+          reply(chat_not_allowed_message) if chat_not_allowed_message
         end
 
-      return unless voice
+        return
+      end
+
+      attempt(3) do
+        voice =
+          if @command == "/transcribe"
+            @replies_to&.voice
+          else
+            @msg.voice
+          end
 
-      send_chat_action(:typing)
+        return unless voice
 
-      file = ogg_to_mp3(download_file(voice))
-      response = send_whisper_request(file[:file])
+        send_chat_action(:typing)
 
-      if response["error"]
-        send_whisper_error(response["error"])
-      else
-        send_whisper_response(response["text"])
+        file = ogg_to_mp3(download_file(voice))
+        response = send_whisper_request(file[:file])
+
+        if response["error"]
+          send_whisper_error(response["error"])
+        else
+          send_whisper_response(response["text"])
+        end
+      ensure
+        FileUtils.rm_rf(file[:names]) if file
       end
-    ensure
-      FileUtils.rm_rf(file[:names]) if file
     end
-  end
 
-  def send_whisper_response(text)
-    reply(text)
-  end
+    def send_whisper_response(text)
+      reply(text)
+    end
 
-  def send_whisper_error
-    reply_code(text)
-  end
+    def send_whisper_error
+      reply_code(text)
+    end
 
-  def ogg_to_mp3(file)
-    ogg = file.original_filename
-    mp3 = ogg.sub(/og.\z/, "mp3")
-    `ffmpeg -i ./#{ogg} -acodec libmp3lame ./#{mp3} -y`
-    { file: File.open("./#{mp3}", "rb"), names: [ogg, mp3] }
-  end
+    def ogg_to_mp3(file)
+      ogg = file.original_filename
+      mp3 = ogg.sub(/og.\z/, "mp3")
+      `ffmpeg -i ./#{ogg} -acodec libmp3lame ./#{mp3} -y 2>/dev/null`
+      { file: File.open("./#{mp3}", "rb"), names: [ogg, mp3] }
+    end
 
-  def send_whisper_request(file)
-    open_ai.audio.transcribe(
-      parameters: {
-        model: "whisper-1",
-        file: file
-      }
-    )
+    def send_whisper_request(file)
+      open_ai.audio.transcribe(
+        parameters: {
+          model: "whisper-1",
+          file: file
+        }
+      )
+    end
   end
 end

data/lib/open_ai_bot.rb

@@ -2,15 +2,16 @@
 
 require_relative "open_ai/chat_gpt"
 require_relative "open_ai/chat_thread"
+require_relative "open_ai/message"
 require_relative "open_ai/dalle"
 require_relative "open_ai/utils"
 require_relative "open_ai/whisper"
 
 class OpenAIBot < Rubydium::Bot
-  include ChatGPT
-  include Dalle
-  include Utils
-  include Whisper
+  include OpenAI::ChatGPT
+  include OpenAI::Dalle
+  include OpenAI::Utils
+  include OpenAI::Whisper
 
   on_every_message :handle_gpt_command
   on_every_message :transcribe

data/main.rb

@@ -6,6 +6,9 @@ require "yaml"
 require "down"
 require "rubydium"
 
+require_relative "lib/ext/blank"
+require_relative "lib/ext/in"
+
 require_relative "lib/open_ai_bot"
 require_relative "lib/clean_bot"
 require_relative "lib/my_custom_bot"

data/open_ai_bot.gemspec

@@ -5,7 +5,7 @@ require_relative "lib/open_ai_bot"
 
 Gem::Specification.new do |spec|
   spec.name          = "open_ai_bot"
-  spec.version       = "0.2.2"
+  spec.version       = "0.2.3"
   spec.authors       = ["bulgakke"]
   spec.email         = ["vvp835@yandex.ru"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: open_ai_bot
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - bulgakke
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-18 00:00:00.000000000 Z
+date: 2023-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -94,10 +94,13 @@ files:
 - README.md
 - config.yaml.example
 - lib/clean_bot.rb
+- lib/ext/blank.rb
+- lib/ext/in.rb
 - lib/my_custom_bot.rb
 - lib/open_ai/chat_gpt.rb
 - lib/open_ai/chat_thread.rb
 - lib/open_ai/dalle.rb
+- lib/open_ai/message.rb
 - lib/open_ai/utils.rb
 - lib/open_ai/whisper.rb
 - lib/open_ai_bot.rb