abot-info 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bbe9530de84f99fcba646a78e0c4a61bb02ebf2e484159817721724cfe6b7733
+  data.tar.gz: 5f1decd77bea3d406a7abe300c9a887391afe9a7991d27561c9a5a34ea8350e4
+SHA512:
+  metadata.gz: 4544c13838da0d2ed4af0e559b02d8c3bac17555a2cd7bdad62d0b1fcf496a13ab8e192205c537e2244775b1e4306c001eb60df1f211ae4244719265fb1565ee
+  data.tar.gz: b647a8cd960afb5e5bbaf739949cddfd6ab1fb4e2055ec9ab6e7228681df5e10cb76d8b4a92a528c48dad85eff855cd96275421da508f5bcdd5c8bc81bd6fcc9

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 6.1.3'
+gem 'paint', '~> 2.2.1'
+gem 'sqlite3', '~> 1.4.2'
+gem 'terminal-table', '~> 3.0.1'
+gem 'binance-ruby', '~> 1.3.1'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 w_dmitrii
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Abot::Info
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/abot/info`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'abot-info'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install abot-info
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/abot-info. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Abot::Info project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/abot-info/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/abot-info.gemspec

@@ -0,0 +1,41 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "abot/info/version"
+
+Gem::Specification.new do |spec|
+  spec.name = 'abot-info'
+  spec.version = Abot::Info::VERSION
+  spec.authors = ['w_dmitrii']
+  spec.email = ['wiz.work2021@gmail.com']
+
+  spec.summary = 'Abot Info'
+  spec.license = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.6')
+
+  spec.files = Dir['lib/**/*.rb', 'exe/*'] + %w[
+    abot-info.gemspec
+    Gemfile
+    LICENSE
+    Rakefile
+    README.md
+  ]
+
+  spec.test_files = Dir['spec/**/*_spec.rb']
+
+  spec.extra_rdoc_files = %w[LICENSE README.md]
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "activerecord", '~> 6.1.3'
+  spec.add_dependency "paint", '~> 2.2.1'
+  spec.add_dependency "sqlite3", '~> 1.4.2'
+  spec.add_dependency "terminal-table", '~> 3.0.1'
+  spec.add_dependency "binance-ruby", '~> 1.3.1'
+end

data/exe/abot-info

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/abot/info'
+
+Abot::Info.run

data/lib/abot/info.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'sqlite3'
+require 'terminal-table'
+require 'paint'
+require 'binance-ruby'
+
+require_relative 'info/option_parser'
+require_relative 'info/coin'
+require_relative 'info/binance_account'
+require_relative 'info/table'
+require_relative 'info/version'
+
+module Abot
+  module Info
+    class << self
+      def run
+        Info::OptionParser.instance do |parser|
+          parser.program_name = 'abot-info'
+          parser.version = Abot::Info::VERSION
+
+          parser.separator ''
+          parser.separator 'Application options:'
+
+          parser.add_option(
+            :template, '--template=TEMPLATE',
+            'Шаблон (default || mobile)',
+          )
+          parser.add_option(
+            :add, '--add=COLUMN1,COLUMN2,COLUMN3',
+            "Добавить колонки:\n" \
+            "                                     name: Названия монет\n" \
+            "                                     name_mobile: Название монет(без изменения по дню)\n" \
+            "                                     sell_up: Прибыль со сделки\n" \
+            "                                     sell_price: Цена продажи\n" \
+            "                                     max_price: Максимальная цена за 24ч.\n" \
+            "                                     min_price: Минимальная цена за 24ч.\n" \
+            "                                     current_price: Текущая цена\n" \
+            "                                     next_average_price: Цена следующего усреднения\n" \
+            "                                     current_quote: Текущая стоимость позиции, $\n" \
+            "                                     buy_date: Дата покупки\n" \
+            "                                     timer: Время с покупки\n" \
+            "                                     current_profit: Текущая прибыль\n" \
+            "                                     potential_profit: Потенциальная прибыль\n",
+          )
+          parser.add_option(
+            :del, '--del=COLUMN1,COLUMN2,COLUMN3',
+            "Удалить колонки:\n" \
+            "                                     name: Названия монет\n" \
+            "                                     name_mobile: Название монет(без изменения по дню)\n" \
+            "                                     sell_up: Прибыль со сделки\n" \
+            "                                     sell_price: Цена продажи\n" \
+            "                                     max_price: Максимальная цена за 24ч.\n" \
+            "                                     min_price: Минимальная цена за 24ч.\n" \
+            "                                     current_price: Текущая цена\n" \
+            "                                     next_average_price: Цена следующего усреднения\n" \
+            "                                     current_quote: Текущая стоимость позиции, $\n" \
+            "                                     buy_date: Дата покупки\n" \
+            "                                     timer: Время с покупки\n" \
+            "                                     current_profit: Текущая прибыль\n" \
+            "                                     potential_profit: Потенциальная прибыль\n",
+          )
+          parser.add_option(
+            :db_path, '--db_path=DB_PATH',
+            'Абсолютный путь до базы A-bot',
+            required: true
+          )
+          parser.add_option(
+            :symbols, '--symbols=SYMBOL1,SYMBOL2,SYMBOL3',
+            'Пары для отображения курсов',
+          )
+        end.final!
+
+        require_relative 'info/database_table'
+
+        start_stats({ rate_coins: rate_coins, columns: columns })
+      end
+
+      def start_stats(opts)
+        while true do
+          begin
+            table = Table.new(opts.merge({ account: binance_account })).generate
+
+            system 'clear'
+            puts table
+          rescue StandardError => e
+            puts "ERROR: #{e.message}"
+          end
+
+          sleep 10
+        end
+      end
+
+      private
+
+      def rate_coins
+        @rate_coins ||= Info::OptionParser.instance.options[:symbols]&.split(',') || []
+      end
+
+      def template
+        @template ||= Info::OptionParser.instance.options[:template]
+      end
+
+      def columns
+        add = Info::OptionParser.instance.options[:add]&.split(',')&.map { |m| m.to_sym } || []
+        del = Info::OptionParser.instance.options[:del]&.split(',')&.map { |m| m.to_sym } || []
+        columns = case template
+                  when 'default'
+                    Table::HEADINGS_COINS_TABLE_DEFAULT
+                  when 'mobile'
+                    Table::HEADINGS_COINS_TABLE_MOBILE
+                  else
+                    []
+                  end
+        columns += add
+        columns -= del
+        Table.last_columns_set(columns)
+      end
+
+      def binance_account
+        BinanceAccount.new(DatabaseTable::API_KEY, DatabaseTable::SECRET_KEY)
+      end
+    end
+  end
+end

data/lib/abot/info/binance_account.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Abot
+  module Info
+    class BinanceAccount
+      attr_reader :api_key, :secret_key
+
+      def initialize(api_key, secret_key)
+        @api_key = api_key
+        @secret_key = secret_key
+      end
+
+      def free_balance(quote)
+        account_info[:balances].find { |f| f[:asset] == quote }.try(:[], :free).to_f
+      end
+
+      def current_balance_btc
+        @current_balance_btc ||= calculation_current_balance_btc
+      end
+
+      def current_balance(balance_btc, quote)
+        calculation_current_balance(balance_btc, quote)
+      end
+
+      def current_balance_wl(current_coins, quote)
+        calculation_current_balance_wl(current_coins, quote)
+      end
+
+      def percent_free_balance(balance, quote)
+        ((free_balance(quote) / balance) * 100).round(2)
+      end
+
+      def account_info
+        @account_info ||= Binance::Api::Account.info!(
+          api_key: api_key,
+          api_secret_key: secret_key,
+          )
+      end
+
+      def potential_balance(current_coins, trade_params)
+        return @potential_balance if @potential_balance
+
+        balance = current_balance(current_balance_btc, 'USDT')
+        quote_assets = trade_params['quote_asset'].split(' ')
+        potential = 0.0
+        btcusdt = get_symbols.find { |f| f[:symbol] == 'BTCUSDT' }
+
+        quote_assets.each do |q|
+          begin
+            pp_q = Coin.sum_potential_profit(current_coins, q) - Coin.sum_current_profit(current_coins, q)
+            if q == 'USDT'
+              potential += pp_q
+            elsif q == 'BTC'
+              potential += pp_q * btcusdt[:askPrice].to_f
+            elsif Coin::FIAT.include?(q)
+              btc = pp_q / get_symbols.find { |f| f[:symbol] == "BTC#{quote_asset}" }[:askPrice].to_f
+              potential += btc * btcusdt[:askPrice].to_f
+            else
+              c = pp_q / get_symbols.find { |f| f[:symbol] == "#{quote_asset}BTC" }[:askPrice].to_f
+              potential += btcusdt[:askPrice].to_f / c
+            end
+          rescue StandardError
+            puts "Ошибка подсчета потенц. баланса: #{q}"
+          end
+        end
+
+        @potential_balance ||= potential + balance
+      end
+
+      def symbol_info(symbol)
+        get_symbols.find { |f| f[:symbol] == symbol }
+      end
+
+      def symbol_min_price(symbol)
+        symbol_info(symbol).try(:[], :lowPrice).to_f
+      end
+
+      def symbol_max_price(symbol)
+        symbol_info(symbol).try(:[], :highPrice).to_f
+      end
+
+      private
+
+      def calculation_current_balance_btc
+        balance = 0.0
+        account_coins = {}
+        account_info[:balances].each do |coin|
+          if coin[:free].to_f != 0 || coin[:locked].to_f != 0
+            account_coins[coin[:asset].to_s] = coin[:free].to_f + coin[:locked].to_f
+          end
+        end
+        if account_coins.present?
+          symbols = get_symbols
+          btcusdt = symbols.find { |f| f[:symbol] == 'BTCUSDT' }[:askPrice].to_f
+          account_coins.each do |name, value|
+            begin
+              if name == 'BTC'
+                balance += account_coins[name]
+              elsif Coin::FIAT.include?(name)
+                coin = symbols.find { |f| f[:symbol] == "BTC#{name}" }
+                balance += value / coin[:askPrice].to_f
+              elsif symbols.find { |f| f[:symbol] == "#{name}USDT" }.nil?
+                coin = symbols.find { |f| f[:symbol] == "#{name}BTC" }
+                balance += coin[:askPrice].to_f * value
+              else
+                coin = symbols.find { |f| f[:symbol] == "#{name}USDT" }
+                balance += coin[:askPrice].to_f * value / btcusdt
+              end
+            rescue StandardError
+              puts "Ошибка при подсчете: монета #{name}"
+            end
+          end
+        end
+        balance
+      end
+
+      def calculation_current_balance(balance_btc, quote)
+        symbols = get_symbols
+        if Coin::FIAT.include?(quote)
+          coin = symbols.find { |f| f[:symbol] == "BTC#{quote}" }
+          balance_btc * coin.try(:[], :askPrice).to_f
+        else
+          coin = symbols.find { |f| f[:symbol] == "#{quote}BTC" }
+          balance_btc / coin.try(:[], :askPrice).to_f
+        end
+      end
+
+      def calculation_current_balance_wl(current_coins, quote)
+        balance = 0.0
+        current_coins = current_coins.select { |s| s.quote_asset == quote }
+        current_coins.each { |coin| balance += coin.current_quote }
+        quote_info = account_info[:balances].find { |f| f[:asset] == quote }
+        if quote_info.present?
+          balance += (quote_info.try(:[], :free).to_f + quote_info.try(:[], :locked).to_f)
+        end
+        balance
+      end
+
+      def get_symbols
+        @get_symbols ||= Binance::Api.ticker!(
+          type: 'daily',
+          api_key: api_key,
+          api_secret_key: secret_key
+        )
+      end
+    end
+  end
+end

data/lib/abot/info/coin.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'decorators/coin_decorator'
+
+module Abot
+  module Info
+    class Coin
+      include Abot::Info::Coin::CoinDecorator
+
+      attr_reader :base_asset, :quote_asset, :average_price, :current_price, :sell_price, :volume, :num_averaging,
+                  :total_quote, :buy_price, :step_averaging, :tick_size, :account, :timer, :trade_params
+
+      FIAT = ['USDT', 'BUSD', 'AUD', 'BIDR', 'BRL', 'EUR', 'GBR', 'RUB', 'TRY', 'TUSD', 'USDC', 'DAI', 'IDRT', 'PAX', 'UAH', 'NGN', 'VAI', 'BVND']
+
+      def initialize(options = {})
+        @trade_params = options[:trade_params]
+        @account = options[:account]
+        @base_asset = options[:base_asset]
+        @quote_asset = options[:quote_asset]
+        @average_price = options[:average_price]
+        @current_price = options[:current_price]
+        @sell_price = options[:sell_price]
+        @volume = options[:volume]
+        @num_averaging = options[:num_averaging]
+        @total_quote = options[:total_quote]
+        @buy_price = options[:buy_price]
+        @step_averaging = options[:step_averaging]
+        @tick_size = options[:tick_size]
+        @timer = options[:timer]
+      end
+
+      def self.current_coins(account, trade_params)
+        DatabaseTable.data_coins.map do |coin|
+          Coin.new(
+            trade_params: trade_params,
+            account: account,
+            base_asset: coin['baseAsset'],
+            quote_asset: coin['quoteAsset'],
+            average_price: coin['averagePrice'].to_f,
+            current_price: coin['askPrice'].to_f,
+            sell_price: coin['sellPrice'].to_f,
+            volume: coin['allQuantity'].to_f,
+            num_averaging: (coin['numAveraging'].to_i - 1),
+            total_quote: coin['totalQuote'].to_f.round(2),
+            buy_price: coin['buyPrice'].to_f,
+            step_averaging: coin['stepAveraging'].to_f,
+            tick_size: coin['tickSize'],
+            timer: coin['timer'].to_s[0..9],
+          )
+        end
+      end
+
+      def self.available_coins_number(current_coins, data_settings, free_balance)
+        aver_arr = []
+        current_coins.each_with_index {|m| aver_arr[m.num_averaging] = ((aver_arr[m.num_averaging].to_i) + 1) }
+        aver_weight = 0
+        aver_arr.each_with_index { |e, idx| aver_weight += (e.to_i * idx) }
+        max_pairs = (free_balance / 100) * data_settings["max_trade_pairs"].to_i
+        progressive_max_pairs = max_pairs - aver_weight
+        progressive_max_pairs.positive? ? progressive_max_pairs.round(0) : 0
+      end
+
+      def self.sum_current_profit(current_coins, quote)
+        current_coins = current_coins.select { |s| s.quote_asset == quote }
+        current_coins.sum(&:current_profit)
+      end
+
+      def self.sum_potential_profit(current_coins, quote)
+        current_coins = current_coins.select { |s| s.quote_asset == quote }
+        current_coins.sum(&:potential_profit)
+      end
+
+      def percent_to_order
+        @percent_to_order ||= ((sell_price / current_price - 1) * 100)
+      end
+
+      def percent_from_min_to_average
+        @percent_to_min ||= ((min_price / next_average_price - 1) * 100)
+      end
+
+      def percent_to_max
+        @percent_to_max ||= ((sell_price / max_price - 1) * 100)
+      end
+
+      def min_price
+        @min_price ||= account.symbol_min_price(symbol)
+      end
+
+      def max_price
+        @max_price ||= account.symbol_max_price(symbol)
+      end
+
+      def current_profit
+        @current_profit ||= ((current_price - average_price) * volume)
+      end
+
+      def potential_profit
+        ((sell_price - average_price) * volume)
+      end
+
+      def current_quote
+        @current_quote ||= (total_quote + current_profit)
+      end
+
+      def sell_up
+        @sell_up ||= ((potential_profit / total_quote) * 100 - 0.15)
+      end
+
+      def next_average_price
+        @next_average_price ||=
+          (buy_price - (buy_price / 100 * (step_averaging - trade_params['buy_down'].to_f))).round(tick_round_size)
+      end
+
+      def next_average_price_percent
+        @next_average_price_percent ||= ((current_price / next_average_price - 1) * 100)
+      end
+
+      def name
+        quote_asset == 'USDT' ? base_asset : symbol
+      end
+
+      def symbol
+        base_asset + quote_asset
+      end
+
+      private
+
+      def tick_round_size
+        @tick_round_size ||= tick_size.length - 2
+      end
+
+    end
+  end
+end

data/lib/abot/info/database_table.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Abot
+  module Info
+    class DatabaseTable
+      DB_PATH = Info::OptionParser.instance.options[:db_path]
+
+      ActiveRecord::Base.establish_connection(
+        adapter: 'sqlite3',
+        database: DB_PATH,
+      )
+
+      BASE_CONNECTION = ActiveRecord::Base.connection
+      API_KEY_TABLE = BASE_CONNECTION.execute('SELECT * FROM api_key').freeze
+      API_KEY = API_KEY_TABLE.first['api'].freeze
+      SECRET_KEY = API_KEY_TABLE.first['secret'].freeze
+
+      class << self
+        def data_coins
+          BASE_CONNECTION.execute('SELECT *  FROM symbols WHERE statusOrder IS NOT "NO_ORDER"')
+        end
+
+        def data_settings
+          BASE_CONNECTION.execute('SELECT *  FROM trade_params').first
+        end
+
+        def data_daily_profit
+          BASE_CONNECTION.execute("SELECT quote, sum(profit) FROM daily_profit GROUP BY quote")
+        end
+      end
+    end
+  end
+end

data/lib/abot/info/decorators/coin_decorator.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Abot
+  module Info
+    class Coin
+      module CoinDecorator
+        def decorated_sell_up
+          rounded_sell_up = sell_up.round(2)
+          case num_averaging
+          when 1, 2
+            rounded_sell_up > 2 ? Paint[rounded_sell_up, :red] : rounded_sell_up
+          when 3, 4, 5
+            rounded_sell_up > 2 ? rounded_sell_up : Paint[rounded_sell_up, :red]
+          else
+            rounded_sell_up
+          end
+        end
+
+        def decorated_current_profit
+          rounded_current_profit = if trade_params['quote_asset'].split(' ').count > 1
+                                     "#{current_profit.round(2)} #{quote_asset}"
+                                   else
+                                     current_profit.round(2)
+                                   end
+          if current_profit >= 0
+            Paint[rounded_current_profit, :green]
+          else
+            Paint[rounded_current_profit, :red]
+          end
+        end
+
+        def decorated_num_averaging
+          Paint[num_averaging, (Helpers::AVERAGE_COLORS[num_averaging] || :red)]
+        end
+
+        def decorated_next_average_price_percent
+          "#{next_average_price_percent.round(2)}%"
+        end
+
+        def decorated_next_average_price
+          "#{next_average_price} (#{decorated_next_average_price_percent})"
+        end
+
+        def decorated_name
+          arrow = if account.symbol_info(symbol).try(:[], :lastPrice).to_f < account.symbol_info(symbol).try(:[], :askPrice).to_f
+                    Paint[' ↑', :green]
+                  elsif account.symbol_info(symbol).try(:[], :lastPrice).to_f > account.symbol_info(symbol).try(:[], :askPrice).to_f
+                    Paint[' ↓', :red]
+                  else
+                    ''
+                  end
+          "#{name}(#{account.symbol_info(symbol).try(:[], :priceChangePercent)}%)#{arrow}"
+        end
+
+        def decorated_name_mobile
+          name
+        end
+
+        def decorated_sell_price
+          sell_price
+        end
+
+        def decorated_current_price
+          "#{current_price} (#{percent_to_order.round(2)}%)"
+        end
+
+        def decorated_min_price
+          "#{min_price} (#{percent_from_min_to_average.round(2)}%)"
+        end
+
+        def decorated_max_price
+          "#{max_price} (#{percent_to_max.round(2)}%)"
+        end
+
+        def decorated_current_quote
+          current_quote.round(2)
+        end
+
+        def decorated_potential_profit
+          if trade_params['quote_asset'].split(' ').count > 1
+            "#{potential_profit.round(2)} #{quote_asset}"
+          else
+            potential_profit.round(2)
+          end
+        end
+
+        def decorated_buy_date
+          Time.at(timer.to_s[0..9].to_f).strftime('%d %h %H:%M')
+        rescue StandardError
+          '-'
+        end
+
+        def decorated_timer
+          medidas = ["г", "мес", "д", "ч", "м", "c"]
+          array = [1970, 1, 1, 0, 0, 0]
+          text = ''
+          Time.at(Time.now.to_i - timer.to_s[0..9].to_f).utc.to_a.take(6).reverse.each_with_index do |k, i|
+            case i
+            when 0, 1, 2
+              next if text.blank? && (k - array[i]).zero?
+
+              text = "#{text} #{k - array[i]}#{medidas[i]}"
+            when 3
+              next_text = (k - array[i]).to_s.rjust(2, '0')
+              text = "#{text} #{next_text}"
+            when 4
+              next_text = (k - array[i]).to_s.rjust(2, '0')
+              text = "#{text}:#{next_text}"
+            end
+          end
+          text
+        rescue StandardError
+          '-'
+        end
+
+        def decorated_cell(name)
+          str = public_send("decorated_#{name}")
+          value = Paint[str, (Helpers::AVERAGE_COLORS[num_averaging] || :red)]
+          row = { value: value }
+          row[:alignment] = :right if name == :timer
+          row
+        end
+      end
+    end
+  end
+end

data/lib/abot/info/helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Abot
+  module Info
+    # helper
+    module Helpers
+      AVERAGE_COLORS = %i[
+        white
+        green
+        cyan
+        yellow
+        magenta
+      ].freeze
+
+      def self.daily_profit_str
+        profit = 'Профит сегодня:'
+        DatabaseTable.data_daily_profit.each do |c|
+          tick_size = (c['quote'] == 'BTC' ? 7 : 2)
+          profit += Paint[" #{c['sum(profit)'].round(tick_size)} #{c['quote']};", :green]
+        end
+        profit
+      end
+
+      def self.balance_str(account, current_coins, trade_params)
+        quote_assets = trade_params['quote_asset'].split(' ')
+        result = ''
+        balance_btc = account.current_balance_btc
+        quote_assets.each_with_index do |quote, idx|
+          result += "\n" unless idx.zero?
+          tick_size = (quote == 'BTC' ? 6 : 2)
+
+          balance = quote == 'BTC' ? balance_btc : account.current_balance(balance_btc, quote)
+          balance_wl = account.current_balance_wl(current_coins, quote)
+
+          cb = "Б: #{Paint["#{balance.round(tick_size)} ", :green]}"
+          cbwl = "Б(WL): #{Paint["#{balance_wl.round(tick_size)} ", :green]}"
+          fb = "С: #{Paint["#{account.free_balance(quote).round(tick_size)} " \
+             "(#{account.percent_free_balance(balance_wl, quote)}%)", :green]} "
+          result += (quote + ' ' + cb + cbwl + fb)
+        end
+        result
+      rescue StandardError
+        ''
+      end
+
+      def self.potential_balance_str(account, current_coins, trade_params)
+        "П: #{Paint["#{account.potential_balance(current_coins, trade_params).round(2)} USDT", :green]}"
+      end
+
+      def self.symbol_price_str(account, symbol_name)
+        symbol = account.symbol_info(symbol_name.to_s)
+        return '' if symbol.nil?
+
+        percent_color = symbol[:priceChangePercent].to_f.positive? ? :green : :red
+        "#{symbol_name}: " + Paint["#{symbol[:askPrice].to_f} (#{symbol[:priceChangePercent]}%)", percent_color]
+      end
+
+      def self.check_abot
+        Paint['WARNING: ПРОВЕРЬТЕ БОТА !!!', :black, :red] + "\n" if (Time.now - File.mtime(DatabaseTable::DB_PATH)) > 10
+      end
+    end
+  end
+end

data/lib/abot/info/option_parser.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'ostruct'
+
+module Abot
+  module Info
+    # Класс раширяет возможности стандартного gem'а
+    #
+    class OptionParser < OptionParser
+      class Error < StandardError; end
+
+      Option = Struct.new(:type, :value, :required)
+      private_class_method :new
+
+      private
+
+      def initialize
+        super
+        @options = {}
+      end
+
+      protected
+
+      def add_help_about_envs
+        envs = @options.select { |_, option| option[:type] == :environment }
+
+        return if envs.empty?
+
+        separator ''
+        separator 'Accessed environments:'
+        envs.each do |key, v|
+          separator ' ' * 4 + [key.to_s.upcase, v[:value]].join('=')
+        end
+      end
+
+      def show_help!
+        show_help = @options.fetch(
+          :help,
+          Option.new(:option, false, false)
+        )
+
+        return unless show_help[:value]
+
+        add_help_about_envs
+
+        print help
+        # получение справочной информации
+        Process.exit! unless ENV.fetch('RUN_TEST', nil)
+      end
+
+      def show_version!
+        show_version = @options.fetch(
+          :version,
+          Option.new(:option, false, false)
+        )
+
+        return unless show_version[:value]
+
+        puts ver
+        # аналогично методу #show_help!
+        Process.exit! unless ENV.fetch('RUN_TEST', nil)
+      end
+
+      def validate!
+        required_options = @options.select do |_, option|
+          option[:required] && option[:value].nil?
+        end
+
+        return if required_options.empty?
+
+        raise Error, <<~ERROR
+          Having problems:
+          #{
+            required_options.map do |key, option|
+              case option[:type]
+              when :environment
+                "- environment '#{key.to_s.upcase}' is required"
+              when :option
+                "- option '#{key}' is required"
+              end
+            end.join("\n")
+          }
+        ERROR
+      end
+
+      public
+
+      def self.instance
+        @instance ||= new
+
+        yield @instance if block_given?
+
+        @instance
+      end
+
+      # Обрабатывает переменную среды окружения и регистрирует его в опциях
+      #
+      # Указанный ключ в аргументе метода, при поиске переменной среды окружения
+      # будет преобразован сл. образом: `:env_key => "ENV_KEY"`
+      #
+      # @param key [Symbol]
+      #
+      # @param default [Object]
+      #
+      # @param required [FalseClass,TrueClass]
+      #
+      def add_env(key, default: nil, required: false)
+        raise Error, 'call after parse' if frozen?
+
+        @options[key] = Option.new(
+          :environment,
+          environment(key.to_s.upcase) || default,
+          required
+        )
+      end
+
+      # Добавляет обработчик опций командной строки
+      #
+      # @param key [Symbol]
+      #
+      # @param args [Array]
+      #
+      # @param default [Object]
+      #
+      # @param required [FalseClass,TrueClass]
+      #
+      def add_option(key, *args, default: nil, required: false)
+        raise Error, 'call after parse' if frozen?
+
+        @options[key] = Option.new(
+          :option,
+          default,
+          required
+        )
+
+        on(*args) { |value| @options[key][:value] = value }
+      end
+
+      # Выполняет обработку входящих аргументов и читает конфигурационый файл
+      #
+      # @return [void]
+      #
+      def final!(args = ARGV)
+        raise Error, 'duplicate call #final!' if frozen?
+
+        parse args
+        load @options[:config_file] ? @options[:config_file][:value] : nil
+        # заполняет значение до заморозки экземпляра класса
+        @banner = "Usage: #{program_name} [options]" if @banner.nil?
+
+        freeze
+
+        show_help!
+        show_version!
+        validate!
+      end
+
+      # Возвращает полученные в результате работы парсера опции
+      #
+      # @param keys_filter [Array<Symbol>] исключает отсуствующие ключи
+      #
+      # @return [Hash]
+      #
+      def options(keys_filter = [])
+        raise Error, 'call before #final!' unless frozen?
+
+        result = @options.each_with_object({}) do |option, acc|
+          acc[option[0]] = option[1][:value] unless option[1][:value].nil?
+        end
+
+        return result if keys_filter.empty?
+
+        result.select { |k, _| keys_filter.include? k }
+      end
+    end
+  end
+end

data/lib/abot/info/table.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+require_relative 'helpers'
+
+module Abot
+  module Info
+    class Table < Terminal::Table
+      include Abot::Info::Helpers
+
+      attr_reader :current_coins, :account, :rate_coins, :columns, :trade_params
+
+      ALL_HEADINGS = {
+        name: 'Coin',
+        name_mobile: 'Coin',
+        sell_up: "sell\nup",
+        sell_price: 'Ордер',
+        max_price: 'Максимум 24h',
+        min_price: 'Минимум 24h',
+        current_price: 'Тек.цена',
+        next_average_price: "Следующее\nусреднение",
+        current_quote: "Тек.\nстоим.",
+        current_profit: "Тек.\nпрофит",
+        potential_profit: "Пот.\nпрофит",
+        buy_date: "Дата покупки",
+        timer: 'Время',
+      }.freeze
+      HEADINGS_COINS_TABLE_DEFAULT = %i[
+        name
+        sell_up
+        sell_price
+        max_price
+        current_price
+        min_price
+        next_average_price
+        current_quote
+        buy_date
+        timer
+        current_profit
+        potential_profit
+      ].freeze
+      HEADINGS_COINS_TABLE_MOBILE = %i[
+        name_mobile
+        sell_up
+        sell_price
+        current_price
+        next_average_price
+      ].freeze
+      COLUMN_WITH_TOTAL = %i[
+        current_profit
+        potential_profit
+      ].freeze
+
+      def initialize(options)
+        @account = options[:account]
+        @columns = options[:columns] || HEADINGS_COINS_TABLE_DEFAULT
+        @rate_coins = options.fetch(:rate_coins, [])
+        @trade_params ||= DatabaseTable.data_settings
+        @current_coins = Coin.current_coins(account, trade_params)
+
+
+        options = {
+          headings: columns.map { |h| { value: ALL_HEADINGS[h], alignment: :center } },
+          style: { border_x: '=' }
+        }
+        super options
+      end
+
+      def self.last_columns_set(col)
+        col = col.map { |m| ALL_HEADINGS.keys.include?(m) ? m : nil }.compact
+        COLUMN_WITH_TOTAL.each { |e| col << col.delete(e) }
+        col.compact
+      end
+
+      def generate
+        sorted_current_coins.each do |coin|
+          row = columns.map do |m|
+            coin.decorated_cell(m)
+          end
+          add_row row
+        end
+        add_separator
+        add_row row_total
+        self
+      end
+
+      def total_averages
+        av_arr = []
+        current_coins.each { |coin| av_arr[coin.num_averaging] = av_arr[coin.num_averaging].to_i + 1 }
+        count = av_arr.compact.sum
+        av_arr = av_arr.map.with_index do |av, idx|
+          Paint["#{idx}: #{av.to_i}", (Helpers::AVERAGE_COLORS[idx] || :red)] if av.to_i != 0
+        end.compact
+        av_arr << "∑: #{count}"
+        # av_arr << "M: #{available_coins_number}" if available_coins_number
+        av_arr.join("\n")
+      end
+
+      def info_str
+        "#{Helpers.check_abot}" \
+        "#{Helpers.daily_profit_str}\n" \
+          "#{Helpers.balance_str(account, current_coins, trade_params)}\n" \
+          "#{Helpers.potential_balance_str(account, current_coins, trade_params)}\n" \
+          "#{rate_coins_str}"
+      end
+
+      def rate_coins_str
+        result = ''
+        rate_coins.each_with_index do |c, idx|
+          number = colspan / 2
+          number += 1 if number.zero?
+
+          result += if idx != 0 && (idx % number).zero?
+                      "\n"
+                    elsif idx != 0
+                      ' '
+                    else
+                      ''
+                    end
+          str = Helpers.symbol_price_str(account, c.upcase)
+          str.slice!('USDT')
+          result += str
+        end
+        result
+      end
+
+      def available_coins_number
+        @available_coins_number ||= Coin.available_coins_number(
+          current_coins,
+          trade_params,
+          account.percent_free_balance(current_coins)
+        )
+      end
+
+      def colspan
+        (columns - COLUMN_WITH_TOTAL).count - 1
+      end
+
+      def row_total
+        row_total = [
+          total_averages,
+          { value: info_str, colspan: colspan }
+        ]
+        quote_assets = trade_params['quote_asset'].split(' ')
+        cell_current_profit = ''
+        cell_potential_profit = ''
+        quote_assets.each do |qa|
+          if quote_assets.count > 1
+            cell_current_profit += "#{Coin.sum_current_profit(current_coins, qa).round(2)} #{qa}\n"if columns.include?(:current_profit)
+            cell_potential_profit += "#{Coin.sum_potential_profit(current_coins, qa).round(2)} #{qa}\n" if columns.include?(:potential_profit)
+          else
+            cell_current_profit += Coin.sum_current_profit(current_coins, qa).round(2).to_s if columns.include?(:current_profit)
+            cell_potential_profit += Coin.sum_potential_profit(current_coins, qa).round(2).to_s if columns.include?(:potential_profit)
+          end
+        end
+        row_total << cell_current_profit if columns.include?(:current_profit)
+        row_total << cell_potential_profit if columns.include?(:potential_profit)
+        row_total
+      end
+
+      def sorted_current_coins
+        current_coins.sort_by(&:percent_to_order)
+      end
+    end
+  end
+end

data/lib/abot/info/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Abot
+  module Info
+    VERSION = '0.1.0'
+  end
+end

data/spec/abot/statistics_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Abot::Info do
+  it "has a version number" do
+    expect(Abot::Info::VERSION).not_to be nil
+  end
+
+  it "does something useful" do
+    expect(false).to eq(true)
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: abot-info
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- w_dmitrii
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: binance-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description:
+email:
+- wiz.work2021@gmail.com
+executables:
+- abot-info
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- abot-info.gemspec
+- exe/abot-info
+- lib/abot/info.rb
+- lib/abot/info/binance_account.rb
+- lib/abot/info/coin.rb
+- lib/abot/info/database_table.rb
+- lib/abot/info/decorators/coin_decorator.rb
+- lib/abot/info/helpers.rb
+- lib/abot/info/option_parser.rb
+- lib/abot/info/table.rb
+- lib/abot/info/version.rb
+- spec/abot/statistics_spec.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Abot Info
+test_files:
+- spec/abot/statistics_spec.rb