lunaris 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18415f6f131d128759635c746a46116dd5fae820875baecd27211cdfcf2a6e63
+  data.tar.gz: 228861eb236f3d8eae1e8e78352a28389eff617068eff54f9935004ffe481052
+SHA512:
+  metadata.gz: 0fb5fc4c6a1c547aae1dd0560d99634055ca35c4559e31c4f8a9d296871b963d0c3aaba8ff0d3ecbe692f698e37f23b33acd485345d2b1e170012b73f9b02191
+  data.tar.gz: 3197810c146528e3094dd693876eecd2cf4f065ae9d369515a94e073438ae0e824dfe7294eb6306f7637b106efef55dd55d0df23165d79faa8ab580bb2db1045

data/README.md

@@ -0,0 +1 @@
+# next-gen-ruby

data/lib/lunaris/autoloader.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+module Lunaris
+  class Autoloader
+    class Inflector < ::Zeitwerk::Inflector
+      INFLECTIONS_MAP = {
+        version: 'VERSION'
+      }.freeze
+
+      def camelize(basename, _abspath)
+        INFLECTIONS_MAP[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      LIB_PATH = ::File.dirname(__dir__).freeze
+
+      def setup!
+        loader = ::Zeitwerk::Loader.new
+        loader.tag = 'lunaris'
+        loader.inflector = Inflector.new
+        loader.push_dir(LIB_PATH)
+        loader.collapse(::File.join(LIB_PATH, 'lunaris', 'resources'))
+
+        ignored_paths.each { |path| loader.ignore(path) }
+
+        loader.setup
+      end
+
+      private
+
+      def ignored_paths
+        [
+          ::File.join(LIB_PATH, 'lunaris', 'patches'),
+          ::File.join(LIB_PATH, 'lunaris', 'config', 'schedule.rb')
+        ].freeze
+      end
+    end
+  end
+end

data/lib/lunaris/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lunaris
+  class Base
+    class << self
+      attr_accessor :app_info
+    end
+
+    self.app_info = ::ENV['APP_INFO'] || "#{::Lunaris::NAME} V #{::Lunaris.version}"
+  end
+end

data/lib/lunaris/config/application.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'tzinfo'
+
+module Lunaris
+  module Config
+    module Application
+      def self.set_timezone(timezone) # rubocop: disable Naming/AccessorMethodName
+        ENV['TZ'] = timezone
+      end
+
+      def self.timestamp_to_date(timestamp)
+        utc_time = Time.at(timestamp).utc
+        tz = TZInfo::Timezone.get('GMT')
+
+        tz.utc_to_local(utc_time)
+      end
+    end
+  end
+end

data/lib/lunaris/config/logger.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'singleton'
+require 'date'
+
+module Lunaris
+  module Config
+    class Logger
+      include Singleton
+      include Lunaris::Helpers::FileHelper
+
+      def initialize
+        log_directory = defined?(RSpec) ? 'spec' : File.expand_path('', Dir.pwd)
+        log_file = "#{log_directory}/#{base_path_hour}/#{file_name}"
+        FileUtils.mkdir_p(File.dirname(log_file))
+
+        @logger = ::Logger.new(log_file)
+        @logger.level = ::Logger::DEBUG
+      end
+
+      def info(message)
+        @logger.info(message)
+      end
+
+      def error(message)
+        @logger.error(message)
+      end
+
+      private
+
+      def file_name
+        env = ENV['APP_ENV'] || 'development'
+
+        "#{env}.log"
+      end
+    end
+  end
+end

data/lib/lunaris/config/sentry_client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'sentry-ruby'
+
+module Lunaris
+  module Config
+    class SentryClient
+      def self.setup
+        return unless defined?(Sentry)
+
+        Sentry.init do |config|
+          config.dsn                = ENV.fetch('SENTRY_DSN', nil)
+          config.traces_sample_rate = 0.2
+          config.environment        = ENV.fetch('APP_ENV', 'development')
+          config.send_default_pii   = true
+        end
+      end
+    end
+  end
+end

data/lib/lunaris/helpers/file_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Helpers
+    module FileHelper
+      def initialize_time
+        @today ||= DateTime.parse(ENV.fetch('DATETIME', DateTime.now))
+      end
+
+      def base_path_day
+        initialize_time
+        "data/#{@today.strftime('%Y-%m-%d')}"
+      end
+
+      def base_path_hour
+        initialize_time
+        "#{base_path_day}/#{@today.strftime('%H')}"
+      end
+    end
+  end
+end

data/lib/lunaris/helpers/loggable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Helpers
+    module Loggable
+      def logger
+        @logger ||= Config::Logger.instance
+      end
+
+      def log_info(message)
+        logger.info(message)
+      end
+    end
+  end
+end

data/lib/lunaris/resources/builders/crypto_market_data_builder.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Builders
+    class CryptoMarketDataBuilder
+      attr_reader :crypto, :tickers, :indicator_obj
+
+      INDICATOR_TYPES = %i[sma_values ema_values macd_values rsi_values sr_values tsi_values bb_values atr_values
+                           kc_values obv_values fgi_values].freeze
+
+      def initialize(crypto, tickers, indicators)
+        @crypto = crypto
+        @tickers = tickers
+        @indicator_obj = Models::Indicator.new(indicators: indicators)
+      end
+
+      def build
+        crypto.to_h.merge(data: build_tickers_data)
+      end
+
+      private
+
+      def build_tickers_data
+        Models::Ticker.sorted_by_date(tickers).first(6).map do |ticker|
+          ticker_data(ticker)
+        end
+      end
+
+      def build_values(type, filtered_indicators)
+        case type
+        when :fgi_values
+          day_builder(filtered_indicators)
+        else
+          datetime_builder(filtered_indicators)
+        end
+      end
+
+      def datetime_builder(values)
+        values.each_slice(2).with_object({}) do |(indicator, index), data|
+          process_indicator(indicator, index, data)
+        end
+      end
+
+      def filter_indicators(type, ticker_datetime)
+        method = type == :fgi_values ? :filter_by_day : :filter_by_datetime
+        indicator_obj.send(method, indicator_obj.indicators.send(type), ticker_datetime)
+      end
+
+      def format_attribute(variable, index)
+        attribute = variable.to_s.delete('@').to_sym
+        attribute = format_sma_ema(attribute, index) if %i[sma ema].include?(attribute)
+        attribute
+      end
+
+      def format_indicators(ticker_datetime)
+        INDICATOR_TYPES.each_with_object({}) do |type, hash|
+          filtered_indicators = filter_indicators(type, ticker_datetime)
+          hash[type] = format_to_hash(build_values(type, filtered_indicators))
+        end
+      end
+
+      def format_sma_ema(attribute, index)
+        suffix = (index.even? ? '10' : '20')
+        :"#{attribute}#{suffix}"
+      end
+
+      def format_to_hash(values)
+        return values if values.is_a?(Hash)
+
+        values.reduce({}, :merge)
+      end
+
+      def process_indicator(indicator, index, data)
+        indicator.instance_variables.each do |variable|
+          attribute = format_attribute(variable, index)
+          next if attribute == :date_time
+
+          data[attribute] = indicator.instance_variable_get(variable)
+        end
+      end
+
+      def ticker_data(ticker)
+        ticker.to_h.merge(format_indicators(ticker.date))
+      end
+
+      def day_builder(values)
+        values.map do |d|
+          {
+            value: d.value,
+            value_classification: d.value_classification,
+            timestamp: Config::Application.timestamp_to_date(d.timestamp.to_i),
+            time_until_update: d.time_until_update
+          }
+        end
+      end
+    end
+  end
+end

data/lib/lunaris/resources/clients/aws.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-lambda'
+
+module Lunaris
+  module Clients
+    class Aws
+      include Lunaris::Helpers::Loggable
+
+      attr_reader :client
+
+      def initialize
+        @client = ::Aws::Lambda::Client.new(
+          access_key_id: ENV.fetch('AWS_ACCESS_KEY_ID'),
+          secret_access_key: ENV.fetch('AWS_SECRET_ACCESS_KEY'),
+          region: ENV.fetch('AWS_REGION', 'eu-west-2')
+        )
+      end
+
+      def invoke(params)
+        response = client.invoke({
+                                   function_name: 'Lunaris',
+                                   invocation_type: 'RequestResponse',
+                                   log_type: 'Tail',
+                                   payload: JSON.generate(params)
+                                 })
+
+        payload = JSON.parse(response.payload.string)
+        log_info("Lambda call with params: #{params} - status: #{payload['statusCode']}")
+        payload['body']
+      end
+    end
+  end
+end

data/lib/lunaris/resources/clients/binance.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+
+module Lunaris
+  module Clients
+    class Binance
+      attr_reader :client, :params
+
+      def initialize(params)
+        @params = params
+        @client = Clients::Aws.new
+      end
+
+      def candlestick
+        lambda_params = { lambda: { class: 'Clients::Binance', method: 'candlestick' } }
+        client.invoke(lambda_params.merge(params))
+      end
+    end
+  end
+end

data/lib/lunaris/resources/clients/fgi.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'fileutils'
+
+module Lunaris
+  module Clients
+    class Fgi
+      attr_accessor :params
+      attr_reader :client, :logger, :today
+
+      def initialize(params)
+        @params = params
+        @client = Clients::Aws.new
+        @today = Date.today
+      end
+
+      def values
+        datetime = DateTime.parse(ENV.fetch('DATETIME', nil))
+        params[:limit] = 10_000 if datetime.to_date < today
+        base_path = "data/#{datetime.strftime('%Y-%m-%d')}"
+
+        file_repo = Repositories::FileStorageRepository.new(base_path, 'fgi.json')
+        data = file_repo.load
+        return data if data
+
+        lambda_params = { lambda: { class: 'Clients::Fgi', method: 'values' } }
+        json_data = client.invoke(lambda_params.merge(params))
+        file_repo.save(json_data)
+        json_data
+      end
+    end
+  end
+end

data/lib/lunaris/resources/controllers/market_automation_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Controllers
+    class MarketAutomationController
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def execute_job
+        Jobs::MarketAutomationJob.new(data).perform
+      end
+    end
+  end
+end

data/lib/lunaris/resources/endpoint.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lunaris
+  class Endpoint
+    attr_reader :logger, :params
+
+    def initialize(params)
+      ENV.fetch('APP_ENV', 'development')
+      Config::Application.set_timezone('GMT')
+      Config::SentryClient.setup
+
+      @params = params
+      set_datetime
+      @logger = Config::Logger.instance
+    end
+
+    def call
+      data = params[:data]
+      controller = Object.const_get(params[:controller_name]).new(data)
+      controller.send(params[:action_name])
+    rescue StandardError => e
+      logger.error("Error occured: #{e.message}")
+      Sentry.capture_exception(e)
+      raise e
+    end
+
+    private
+
+    def set_datetime
+      if params&.dig(:data, :timestamps, :end)
+        timestamp = params.dig(:data, :timestamps, :end) / 1000
+        datetime = Config::Application.timestamp_to_date(timestamp)
+        ENV['DATETIME'] = datetime.to_s
+      else
+        ENV['DATETIME'] = Time.now.to_s
+      end
+    end
+  end
+end

data/lib/lunaris/resources/jobs/market_automation_job.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Lunaris
+  module Jobs
+    class MarketAutomationJob
+      include Lunaris::Helpers::Loggable
+
+      attr_reader :params
+
+      def initialize(params = nil)
+        @params = params
+        @logger = Config::Logger.instance
+      end
+
+      def perform
+        cryptos = Models::Crypto.all
+        log_info("MarketAutomationJob started with #{cryptos.size} cryptos")
+
+        futures = create_pipelines(cryptos)
+        Concurrent::Promises.zip(*futures).value!
+
+        log_info('MarketAutomationJob completed successfully')
+      end
+
+      private
+
+      def create_pipelines(cryptos)
+        cryptos.map do |crypto|
+          Concurrent::Promises.future do
+            context = OpenStruct.new(crypto: crypto, params: params)
+            Services::CryptoMarketDataPipeline.new(context).process
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lunaris/resources/models/crypto.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Lunaris
+  module Models
+    class Crypto
+      DEFAULT_TICKER_PARAMS = { interval: '1h', limit: 50 }.freeze
+      FILE_PATH = 'data/cryptos.csv'
+
+      attr_reader :name, :symbol
+
+      def initialize(params)
+        @name, @symbol = params.values_at(:name, :symbol)
+      end
+
+      def self.all
+        CSV.foreach(FILE_PATH, headers: true).map do |row|
+          Models::Crypto.new(name: row['Name'], symbol: row['Symbol'])
+        end
+      end
+
+      def tickers(params = nil)
+        params = DEFAULT_TICKER_PARAMS.merge(params || {})
+                                      .merge(symbol: "#{symbol}USDT")
+
+        candles = Clients::Binance.new(params).candlestick
+        candles.map { |entry| Models::Ticker.new(entry, self) }
+      end
+
+      def to_h
+        {
+          crypto: {
+            name: name,
+            symbol: symbol
+          }
+        }
+      end
+    end
+  end
+end

data/lib/lunaris/resources/models/crypto_market_data.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Models
+    class CryptoMarketData
+      attr_reader :crypto, :tickers, :indicators
+
+      def initialize(crypto, tickers, indicators)
+        @crypto = crypto
+        @tickers = tickers
+        @indicators = indicators
+      end
+
+      def to_h
+        Builders::CryptoMarketDataBuilder.new(crypto, tickers, indicators).build
+      end
+    end
+  end
+end

data/lib/lunaris/resources/models/indicator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'technical-analysis'
+
+module Lunaris
+  module Models
+    class Indicator
+      DATA_PERIOD = {
+        adi: 20, atr: 20, bb: 25, cmf: 25,
+        ema10: 15, ema20: 25, kc: 15, macd: 39,
+        mfi: 20, obv: 20, rsi: 20, sma10: 15,
+        sma20: 25, sr: 21, tsi: 43, vwap: 25
+      }.freeze
+
+      attr_reader :cache_data, :indicators, :tickers
+
+      def initialize(tickers: nil, indicators: nil)
+        if tickers
+          @tickers = tickers
+          @cache_data = {}
+          cache_data_by_periods(DATA_PERIOD.values.uniq)
+        else
+          @indicators = indicators
+        end
+      end
+
+      def calculate(type, options = {})
+        indicator_class = Object.const_get("TechnicalAnalysis::#{type.capitalize}")
+        key = :"#{type}#{options[:period]}"
+        period = DATA_PERIOD[type.to_sym] || DATA_PERIOD[key]
+
+        if %i[adi obv vwap].map(&:to_s).include?(type)
+          indicator_class.calculate(cache_data[period])
+        else
+          indicator_class.calculate(cache_data[period], options)
+        end
+      end
+
+      def filter_by_datetime(values, datetime, index = 0)
+        unless values.any?(&:date_time)
+          all_values = []
+
+          [values.sma10, values.sma20, values.ema10, values.ema20].each_with_index do |indicator_list, index|
+            all_values << filter_by_datetime(indicator_list, datetime, index) if indicator_list&.any?
+          end
+
+          return all_values.flatten
+        end
+
+        filtered_indicators = values.select { |value| value.date_time == datetime }
+        [filtered_indicators, index].flatten
+      end
+
+      def filter_by_day(data, ticker_datetime)
+        ticker_time = Time.parse(ticker_datetime)
+        ticker_timestamp = ticker_time.to_date.to_time.to_i
+
+        data.select { |d| d.timestamp == ticker_timestamp }
+      end
+
+      private
+
+      def cache_data_by_periods(periods)
+        periods.each { |period| cache_data[period] ||= tickers.last(period) }
+      end
+    end
+  end
+end

data/lib/lunaris/resources/models/ticker.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Models
+    class Ticker
+      attr_reader :date, :open_price, :close_price, :high_price, :low_price, :volume, :crypto
+
+      def initialize(candle_params, crypto)
+        @date, @open_price, @close_price, @high_price, @low_price, @volume =
+          %i[date open_price close_price high_price low_price volume].map { |k| candle_params[k.to_s] }
+
+        @crypto = crypto
+      end
+
+      def self.sorted_by_date(tickers)
+        tickers.sort_by { |ticker| -Time.parse(ticker.date).to_i }
+      end
+
+      def to_h
+        {
+          date: date,
+          open_price: open_price,
+          close_price: close_price,
+          high_price: high_price,
+          low_price: low_price,
+          volume: volume
+        }
+      end
+    end
+  end
+end

data/lib/lunaris/resources/repositories/file_storage_repository.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Lunaris
+  module Repositories
+    class FileStorageRepository
+      attr_reader :base_directory, :file_name
+
+      def initialize(base_directory, file_name)
+        @base_directory = File.join(Dir.pwd, base_directory)
+        @file_name = File.join(@base_directory, file_name)
+        @file_name.sub!('data', 'spec/data') if defined?(RSpec)
+      end
+
+      def save(data)
+        FileUtils.mkdir_p(File.dirname(file_name))
+        File.write(file_name, to_json(data))
+      end
+
+      def load
+        return JSON.parse(File.read(file_name)) if File.exist?(file_name)
+
+        nil
+      end
+
+      private
+
+      def to_json(data)
+        JSON.pretty_generate(data)
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/crypto_market_data_pipeline.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    class CryptoMarketDataPipeline
+      include Lunaris::Helpers::FileHelper
+      include Lunaris::Helpers::Loggable
+
+      attr_reader :crypto, :params
+
+      def initialize(context)
+        @crypto = context.crypto
+        @params = context.params
+        @file_base_path = base_path_hour
+      end
+
+      def process
+        log_info("Processing crypto #{crypto.name} ...")
+
+        tickers = retrieve_tickers
+        indicators = calculate_indicators(tickers)
+        export_data(tickers, indicators)
+
+        log_info("Export data for #{crypto.name}")
+      end
+
+      private
+
+      def calculate_indicators(tickers)
+        indicators = Services::IndicatorService.new(tickers).calculate_all
+        log_info("Calculation of indicators for #{crypto.name}: OK")
+        indicators
+      end
+
+      def export_data(tickers, indicators)
+        data = Models::CryptoMarketData.new(crypto, tickers, indicators).to_h
+        Repositories::FileStorageRepository.new(@file_base_path, "#{crypto.name}.json").save(data)
+      end
+
+      def retrieve_tickers
+        tickers = crypto.tickers(params)
+        log_info("Found #{tickers.count} tickers for #{crypto.name}")
+        tickers
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicator_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    class IndicatorService
+      attr_reader :indicator_obj
+
+      INDICATOR_CLASSES = {
+        trend_following: Indicators::TrendFollowing,
+        momentum: Indicators::Momentum,
+        volatility: Indicators::Volatility,
+        volume_based: Indicators::VolumeBased,
+        sentiment: Indicators::Sentiment
+      }.freeze
+
+      def initialize(tickers)
+        price_data = load_data(tickers).freeze
+        @indicator_obj = Models::Indicator.new(tickers: price_data)
+
+        initialize_indicators
+      end
+
+      INDICATOR_CLASSES.each_key do |indicator|
+        define_method(indicator) do
+          instance_variable_get("@#{indicator}").calculate_all
+        end
+      end
+
+      def calculate_all
+        futures = INDICATOR_CLASSES.keys.map do |indicator|
+          Concurrent::Future.execute do
+            instance_variable_get("@#{indicator}").calculate_all
+          end
+        end
+
+        results = futures.map(&:value).reduce({}) do |acc, struct|
+          acc.merge(struct.to_h)
+        end
+
+        OpenStruct.new(results)
+      end
+
+      private
+
+      def initialize_indicators
+        INDICATOR_CLASSES.each do |indicator, klass|
+          instance_variable_set("@#{indicator}", klass.new(indicator_obj))
+        end
+      end
+
+      def load_data(tickers)
+        tickers.map do |t|
+          { date_time: t.date, open: t.open_price, high: t.high_price,
+            low: t.low_price, close: t.close_price, volume: t.volume }
+        end
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicators/base_indicator_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    module Indicators
+      class BaseIndicatorService
+        attr_reader :indicator_obj
+
+        def initialize(indicator_obj)
+          @indicator_obj = indicator_obj
+        end
+
+        def calculate_all
+          results = self.class::OPTIONS.each_with_object({}) do |(type, opts), result|
+            result[:"#{type}_values"] = calculate_indicator_for(type, opts)
+          end
+
+          OpenStruct.new(results)
+        end
+
+        private
+
+        def calculate_indicator_for(type, opts)
+          if %i[sma ema].include?(type)
+            calculate_moving_average(type)
+          else
+            calculate_indicator(type, opts)
+          end
+        end
+
+        def calculate_moving_average(type)
+          OpenStruct.new(
+            self.class::OPTIONS[type].transform_values { |opts| calculate_indicator(type, opts) }
+          )
+        end
+
+        def calculate_indicator(type, opts = nil)
+          indicator_obj.calculate(type.to_s, opts || self.class::OPTIONS[type])
+        end
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicators/momentum.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    module Indicators
+      class Momentum < BaseIndicatorService
+        OPTIONS = {
+          rsi: { period: 14, price_key: :close },
+          sr: {},
+          tsi: { low_period: 13, high_period: 25, price_key: :close }
+        }.freeze
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicators/sentiment.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module Lunaris
+  module Services
+    module Indicators
+      class Sentiment < BaseIndicatorService
+        OPTIONS = {
+          adi: { period: 14, price_key: :close },
+          mfi: {}
+        }.freeze
+
+        @fgi_semaphore = Concurrent::Semaphore.new(1)
+
+        def calculate_all
+          OpenStruct.new({
+                           fgi_values: fear_greed_index,
+                           adi_values: calculate_indicator(:adi),
+                           mfi_values: calculate_indicator(:mfi)
+                         })
+        end
+
+        def fear_greed_index(limit = 6)
+          params = { limit: limit }
+          self.class.fgi_semaphore.acquire
+
+          begin
+            deep_struct(Clients::Fgi.new(params).values)
+          ensure
+            self.class.fgi_semaphore.release
+          end
+        end
+
+        private
+
+        def deep_struct(obj)
+          case obj
+          when Hash
+            OpenStruct.new(obj.transform_values { |v| deep_struct(to_i(v)) })
+          when Array
+            obj.map { |v| deep_struct(v) }
+          else
+            to_i(obj)
+          end
+        end
+
+        def to_i(value)
+          value.to_s.match?(/^\d+$/) ? value.to_i : value
+        end
+
+        class << self
+          attr_reader :fgi_semaphore
+        end
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicators/trend_following.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    module Indicators
+      class TrendFollowing < BaseIndicatorService
+        OPTIONS = {
+          sma: { 'sma10' => { period: 10, price_key: :close }, 'sma20' => { period: 20, price_key: :close } },
+          ema: { 'ema10' => { period: 10, price_key: :close }, 'ema20' => { period: 20, price_key: :close } },
+          macd: { fast_period: 12, slow_period: 26, signal_period: 9, price_key: :close }
+        }.freeze
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicators/volatility.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    module Indicators
+      class Volatility < BaseIndicatorService
+        OPTIONS = {
+          bb: { period: 20, price_key: :close },
+          atr: {},
+          kc: {}
+        }.freeze
+      end
+    end
+  end
+end

data/lib/lunaris/resources/services/indicators/volume_based.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lunaris
+  module Services
+    module Indicators
+      class VolumeBased < BaseIndicatorService
+        OPTIONS = {
+          obv: { period: 20, price_key: :close },
+          cmf: { period: 20 },
+          vwap: {}
+        }.freeze
+      end
+    end
+  end
+end

data/lib/lunaris/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lunaris
+  VERSION = '0.0.0'
+end

data/lib/lunaris.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lunaris/autoloader'
+
+module Lunaris
+  NAME = 'Lunaris Ruby'
+
+  @mutex = ::Mutex.new
+
+  class << self
+    def app_info=(value)
+      ::Lunaris::Base.app_info = value
+    end
+
+    def ping
+      { status: 200 }
+    end
+
+    def version
+      VERSION
+    end
+  end
+end
+
+Lunaris::Autoloader.setup!

metadata

@@ -0,0 +1,242 @@
+--- !ruby/object:Gem::Specification
+name: lunaris
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Stefano Baldazzi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-lambda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: file_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sentry-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: technical-analysis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.6
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: Lunaris is a lightweight gem for manage crypto operations.
+email:
+- stefanobaldazzi40@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/lunaris.rb
+- lib/lunaris/autoloader.rb
+- lib/lunaris/base.rb
+- lib/lunaris/config/application.rb
+- lib/lunaris/config/logger.rb
+- lib/lunaris/config/sentry_client.rb
+- lib/lunaris/helpers/file_helper.rb
+- lib/lunaris/helpers/loggable.rb
+- lib/lunaris/resources/builders/crypto_market_data_builder.rb
+- lib/lunaris/resources/clients/aws.rb
+- lib/lunaris/resources/clients/binance.rb
+- lib/lunaris/resources/clients/fgi.rb
+- lib/lunaris/resources/controllers/market_automation_controller.rb
+- lib/lunaris/resources/endpoint.rb
+- lib/lunaris/resources/jobs/market_automation_job.rb
+- lib/lunaris/resources/models/crypto.rb
+- lib/lunaris/resources/models/crypto_market_data.rb
+- lib/lunaris/resources/models/indicator.rb
+- lib/lunaris/resources/models/ticker.rb
+- lib/lunaris/resources/repositories/file_storage_repository.rb
+- lib/lunaris/resources/services/crypto_market_data_pipeline.rb
+- lib/lunaris/resources/services/indicator_service.rb
+- lib/lunaris/resources/services/indicators/base_indicator_service.rb
+- lib/lunaris/resources/services/indicators/momentum.rb
+- lib/lunaris/resources/services/indicators/sentiment.rb
+- lib/lunaris/resources/services/indicators/trend_following.rb
+- lib/lunaris/resources/services/indicators/volatility.rb
+- lib/lunaris/resources/services/indicators/volume_based.rb
+- lib/lunaris/version.rb
+homepage: https://github.com/Baldaz02/next-gen-ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key: 
+specification_version: 4
+summary: lunaris-0.0.0
+test_files: []