fino 1.9.1 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d244c8f2e96f931cda9cb2b996d8cddaa37232ba06a1d5a8780a42121b45b025
-  data.tar.gz: 641f2f41ab79d7685036704e76879389509f82b4d096f00f2ab07404dfdc5db4
+  metadata.gz: b848e452b4dd15c07680a8e27822e978a35152e8a2fcf24193e61af3bdbc2c55
+  data.tar.gz: dabde784e2b9c36d9f258b70a9885052f8d567e0ffc21ace004d1441bb219651
 SHA512:
-  metadata.gz: d3940a3eae361e59e2696ac55b254a8199cd9f450b872e7f34b94b415591590850973eef1811b9358d76351b41445f01bc21649e9dc68ec4fd7b5d175990a5cf
-  data.tar.gz: cd740a8f69fb2a91f4a9c3b15822e0c6ee45ae22e606e909994ef19c7062afd2e979a8bbae09484ab8963c817ad8455944039269cdcdc3ebef51cdf3afb8142a
+  metadata.gz: 795b2922a6b205ce6e9015f34c69d7cf7b5b501d54cec81968766d6510148d734b1f0c09fd3193646616759b826964aef9def7d7a572e11dbe362ca50f06a6fe
+  data.tar.gz: 9a85da0390f427490012c41a2eb004bbdb7bdabdf7a2166da450fc7e003d010f9a97baed16ea2f6cdb316a41474703198220ebb2dda0b28bac12cf86d7f96775

data/README.md

@@ -83,6 +83,126 @@ Fino.disable(:maintenance_mode, for: "qa")
 Fino.enabled?(:maintenance_mode, for: "qa") #=> false
 ```
 
+### Select setting
+
+The simplest way to define select setting in fino is the following
+
+```ruby
+Fino.configure do
+  # ...
+  section :storefront, label: "Storefront" do
+    setting :purchase_button_color,
+            :select,
+            options: [
+              Fino::Settings::Select::Option.new(label: "Red", value: "red"),
+              Fino::Settings::Select::Option.new(label: "Blue", value: "blue")
+            ],
+            default: "red",
+            description: "Color of the purchase button"
+  end
+  # ...
+end
+```
+
+Options must be an array of `Fino::Settings::Select::Option` instances
+
+Then you can interact with the setting like that
+
+```ruby
+# Read selected option
+selected_option = Fino.value(:purchase_button_color, at: :storefront)
+# => #<Fino::Settings::Select::Option:0x0000000124fecd90 @label="Red", @metadata={}, @value="red">
+
+# Read setting value
+selected_option.value
+# => "red"
+
+# Read options
+Fino.setting(:purchase_button_color, at: :storefront).options
+# => [#<Fino::Settings::Select::Option:0x0000000124fecd90 @label="Red", @metadata={}, @value="red">,
+      #<Fino::Settings::Select::Option:0x0000000124fecca0 @label="Blue", @metadata={}, @value="blue">]
+```
+
+#### Dynamic option
+
+Options can also be defined dynamically using any callable object. Let's take a look at dynamic options in an example
+of LLM model setting using [RubyLLM](https://github.com/crmne/ruby_llm) by @crmne
+
+To define dynamic select options, use `:select` as setting type and provide a callable to `options`. Your object's
+`call` method might be called with `refresh` option which is true only when user initiates options refresh manually.
+This is useful for updating models list in RubyLLM for example
+
+```ruby
+section :llm, label: "LLM" do
+  setting :model,
+          :select,
+          options: proc { |refresh:|
+            RubyLLM.models.refresh! if refresh
+            models = RubyLLM.models.chat_models
+
+            openai_models = models.by_provider(:openai)
+            anthropic_models = models.by_provider(:anthropic)
+
+            build_pricing_label = proc do |model|
+              text_pricing = model.pricing&.text_tokens
+              next unless text_pricing && text_pricing.input && text_pricing.output
+
+              "$#{text_pricing.input} / $#{text_pricing.output} per 1M tokens"
+            end
+
+            [*openai_models, *anthropic_models].map do |model|
+              Fino::Settings::Select::Option.new(
+                label: model.name,
+                value: model.id,
+                metadata: {
+                  provider: model.provider_class.name,
+                  pricing: build_pricing_label.call(model)
+                }.compact
+              )
+            end
+          },
+          default: "gpt-5",
+          description: "Chat model for AI-powered features"
+  end
+end
+```
+
+```ruby
+# Read selected option
+selected_option = Fino.setting(:model, at: :llm).value
+# => #<Fino::Settings::Select::Option:0x0000000126257728
+#     @label="GPT-4",
+#     @metadata={provider: "OpenAI", pricing: "$30 / $60 per 1M tokens"},
+#     @value="gpt-4">
+
+# Read setting value
+selected_option.value
+# => "gpt-4"
+
+# Read options
+Fino.setting(:model, at: :llm).options
+# => [#<Fino::Settings::Select::Option:0x000000012629e448
+#      @label="GPT-5.3 Codex Spark",
+#      @metadata={provider: "OpenAI", pricing: "$1.75 / $14 per 1M tokens"},
+#      @value="gpt-5.3-codex-spark">,
+#     #<Fino::Settings::Select::Option:0x000000012629e1c8
+#      @label="GPT-5.4",
+#      @metadata={provider: "OpenAI", pricing: "$2.5 / $15 per 1M tokens"},
+#      @value="gpt-5.4">, ...]
+
+# Refresh options
+Fino.setting(:model, at: :llm).refresh!
+# I, [2026-03-22T18:23:13.615270 #67293]  INFO -- RubyLLM: Fetching models from providers:
+# I, [2026-03-22T18:23:13.615934 #67293]  INFO -- RubyLLM: Fetching models from models.dev API...
+```
+
+#### Use with RubyLLM
+
+```ruby
+chat = RubyLLM.chat(model: Fino.setting(:model, at: :llm).value)
+chat.ask "Why Ruby?"
+```
+
 ### Overrides
 
 ```ruby
@@ -116,6 +236,44 @@ Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
 Fino.value(:model, at: :openai, for: "user_2") #=> "gpt-5"
 ```
 
+#### Experiment analysis
+
+Some Fino adapters support A/B testing analysis, e.g built-in Redis adapter
+
+When you run an A/B test for a setting, fino automatically calculates variant based on a stable identifier you pass as
+a `for` option
+
+```ruby
+Fino.set(model: "gpt-5", at: :openai, variants: { 20.0 => "gpt-6" })
+
+Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
+Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
+
+Fino.value(:model, at: :openai, for: "user_2") #=> "gpt-5"
+```
+
+Later in your code, when user performs a "desired" action, simply call
+
+```ruby
+Fino.convert!(:model, at: :openai, for: "user_2")
+```
+
+to record a "convertion" for `user_2`. As Fino knows the right variant for `user_2`, conversion will be counted
+todards it. Thanks to that later you'll be able to call
+
+```ruby
+Fino.analyse(:model, at: :openai)
+```
+
+to receive a detailed report over variants performance. Also bar charts comparing all variants and a chart displaying
+amount of conversions over time per variant will be accessible on UI with `fino-rails`
+
+To reset analysis data for an experiment:
+
+```ruby
+Fino.reset_analysis!(:model, at: :openai)
+```
+
 ### Unit conversion
 
 Fino is able to convert numeric settings into various units

data/lib/fino/ab_testing/analysis.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Fino::AbTesting::Analysis
+  class VariantData
+    attr_reader :variant, :conversions_count, :daily_conversions
+
+    def initialize(variant:, conversions_count:, daily_conversions:)
+      @variant = variant
+      @conversions_count = conversions_count
+      @daily_conversions = daily_conversions
+    end
+  end
+
+  class << self
+    def from_raw_conversions(setting_instance, raw_conversions) # rubocop:disable Metrics/MethodLength
+      experiment = setting_instance.experiment
+
+      variants_data = experiment.variants.map do |variant|
+        entries = raw_conversions.fetch(variant, [])
+
+        daily_conversions = entries
+                            .group_by { |_scope, score| Time.at(score / 1000.0).to_date.to_s }
+                            .transform_values(&:size)
+
+        Fino::AbTesting::Analysis::VariantData.new(
+          variant: variant,
+          conversions_count: entries.size,
+          daily_conversions: daily_conversions
+        )
+      end
+
+      Fino::AbTesting::Analysis.new(variants_data)
+    end
+  end
+
+  attr_reader :variants_data
+
+  def initialize(variants_data)
+    @variants_data = variants_data
+  end
+
+  def any_conversions?
+    variants_data.any? { |vd| vd.conversions_count > 0 }
+  end
+
+  def total_conversions
+    variants_data.sum(&:conversions_count)
+  end
+end

data/lib/fino/ab_testing/variant.rb

@@ -5,19 +5,25 @@ class Fino::AbTesting::Variant
     def inspect
       "Fino::AbTesting::Variant::CONTROL_VALUE"
     end
+
+    def to_s
+      "control"
+    end
   end.new
 
   include Fino::PrettyInspectable
 
-  attr_reader :id, :percentage, :value
+  attr_reader :percentage, :value
 
   def initialize(percentage:, value:)
-    @id = SecureRandom.uuid
-
     @percentage = percentage.to_f
     @value = value
   end
 
+  def id
+    "#{percentage}-#{value}"
+  end
+
   private
 
   def inspectable_attributes

data/lib/fino/adapter.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 module Fino::Adapter
+  AB_TESTING_ANALYSIS_METHODS = %i[record_ab_testing_conversion read_ab_testing_conversions clear_ab_testing_conversions].freeze
+
+  def supports_ab_testing_analysis?
+    AB_TESTING_ANALYSIS_METHODS.all? { |method| respond_to?(method) }
+  end
+
   def read(setting_key)
     raise NotImplementedError
   end

data/lib/fino/definition/setting.rb

@@ -5,7 +5,8 @@ class Fino::Definition::Setting
     Fino::Settings::String,
     Fino::Settings::Integer,
     Fino::Settings::Float,
-    Fino::Settings::Boolean
+    Fino::Settings::Boolean,
+    Fino::Settings::Select
   ].freeze
 
   SETTING_TYPE_TO_TYPE_CLASS_MAPPING = TYPE_CLASSES.each_with_object({}) do |klass, hash|
@@ -27,8 +28,16 @@ class Fino::Definition::Setting
     end
   end
 
+  def serialize(value)
+    type_class.serialize(self, value)
+  end
+
+  def deserialize(raw_value)
+    type_class.deserialize(self, raw_value)
+  end
+
   def default
-    defined?(@default) ? @default : @default = type_class.deserialize(options[:default])
+    defined?(@default) ? @default : @default = deserialize(options[:default])
   end
 
   def description
@@ -40,11 +49,11 @@ class Fino::Definition::Setting
   end
 
   def path
-    @path ||= [setting_name, section_definition&.name].compact
+    @path ||= [section_definition&.name, setting_name].compact
   end
 
   def key
-    @key ||= path.reverse.join("/")
+    @key ||= path.join("/")
   end
 
   def eql?(other)

data/lib/fino/ext/hash.rb

@@ -3,7 +3,7 @@
 module Fino::Ext::Hash
   refine Hash do
     def deep_set(value, *path)
-      item = path.pop
+      item = path.shift
 
       if path.empty?
         self[item] = value

data/lib/fino/library/ab_testing_analysis_support.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Fino::Library::AbTestingAnalysisSupport
+  SettingNotAbTested = Class.new(Fino::Error)
+  AdapterDoesNotSupportAbTestingAnalysis = Class.new(Fino::Error)
+
+  def convert!(setting_name, at: nil, for: nil, time: Time.now)
+    ensure_ab_testing_analysis_supported!
+
+    scope = binding.local_variable_get(:for)
+
+    setting_instance = fetch_ab_testable_setting(setting_name, at: at)
+    variant = setting_instance.experiment.variant(for: scope)
+    timestamp_ms = (time.to_f * 1000).to_i
+
+    adapter.record_ab_testing_conversion(setting_instance.definition, variant, scope, timestamp_ms)
+  end
+
+  def convert(setting_name, at: nil, time: Time.now, **context)
+    convert!(setting_name, at: at, time: time, **context)
+  rescue SettingNotAbTested, AdapterDoesNotSupportAbTestingAnalysis
+    nil
+  end
+
+  def analyse(setting_name, at: nil)
+    ensure_ab_testing_analysis_supported!
+
+    setting_instance = fetch_ab_testable_setting(setting_name, at: at)
+    raw_conversions = adapter.read_ab_testing_conversions(
+      setting_instance.definition,
+      setting_instance.experiment.variants
+    )
+
+    Fino::AbTesting::Analysis.from_raw_conversions(setting_instance, raw_conversions)
+  end
+
+  def reset_analysis!(setting_name, at: nil)
+    ensure_ab_testing_analysis_supported!
+
+    setting_instance = fetch_ab_testable_setting(setting_name, at: at)
+    adapter.clear_ab_testing_conversions(setting_instance.definition.key)
+  end
+
+  private
+
+  def ensure_ab_testing_analysis_supported!
+    return if adapter.supports_ab_testing_analysis?
+
+    raise AdapterDoesNotSupportAbTestingAnalysis, "Adapter #{adapter.class.name} does not support A/B testing analysis"
+  end
+
+  def fetch_ab_testable_setting(setting_name, at: nil)
+    setting(setting_name, at: at).tap do |setting_instance|
+      raise SettingNotAbTested, "Setting #{setting_name} is not A/B tested" unless setting_instance.ab_tested?
+    end
+  end
+end

data/lib/fino/library.rb

@@ -4,6 +4,7 @@ require "forwardable"
 
 class Fino::Library
   include FeatureTogglesSupport
+  include AbTestingAnalysisSupport
 
   def initialize(configuration)
     @configuration = configuration
@@ -40,7 +41,7 @@ class Fino::Library
     setting_definition = build_setting_definition(setting_name, at: at)
     current_setting = pipeline.read(setting_definition)
 
-    deserialized_overrides = overrides.transform_values { |v| setting_definition.type_class.deserialize(v) }
+    deserialized_overrides = overrides.transform_values { |v| setting_definition.deserialize(v) }
     merged_overrides = current_setting.overrides.merge(deserialized_overrides)
 
     variants = current_setting.experiment&.variants || []
@@ -62,16 +63,16 @@ class Fino::Library
 
     setting_name, raw_value = data.first
     setting_definition = build_setting_definition(setting_name, at: at)
-    value = setting_definition.type_class.deserialize(raw_value)
+    value = setting_definition.deserialize(raw_value)
 
-    overrides = raw_overrides.transform_values { |v| setting_definition.type_class.deserialize(v) }
+    overrides = raw_overrides.transform_values { |v| setting_definition.deserialize(v) }
 
     experiment = Fino::AbTesting::Experiment.new(setting_definition)
 
     raw_variants.map do |percentage, value|
       experiment << Fino::AbTesting::Variant.new(
         percentage: percentage,
-        value: setting_definition.type_class.deserialize(value)
+        value: setting_definition.deserialize(value)
       )
     end
 
@@ -113,7 +114,7 @@ class Fino::Library
   attr_reader :configuration
 
   def build_setting_definition(setting_name, at: nil)
-    configuration.registry.setting_definition!(setting_name.to_s, at&.to_s)
+    configuration.registry.setting_definition!(setting_name.to_s, at: at&.to_s)
   end
 
   def pipeline

data/lib/fino/registry.rb

@@ -51,7 +51,7 @@ class Fino::Registry
 
   using Fino::Ext::Hash
 
-  attr_reader :setting_definitions, :section_definitions
+  attr_reader :setting_definitions, :section_definitions, :option_registry
 
   def initialize
     @setting_definitions = Set.new
@@ -59,14 +59,16 @@ class Fino::Registry
 
     @section_definitions = Set.new
     @section_definitions_by_name = {}
+
+    @option_registry = Fino::Settings::Select::OptionRegistry.new
   end
 
-  def setting_definition(*path)
-    @setting_definitions_by_path.dig(*path.compact.reverse.map(&:to_s))
+  def setting_definition(setting_name, at: nil)
+    @setting_definitions_by_path.dig(*[at, setting_name].compact.map(&:to_s))
   end
 
-  def setting_definition!(*path)
-    setting_definition(*path).tap do |definition|
+  def setting_definition!(setting_name, at: nil)
+    setting_definition(setting_name, at: at).tap do |definition|
       raise UnknownSetting, "Unknown setting: #{path.compact.join('.')}" unless definition
     end
   end
@@ -91,7 +93,18 @@ class Fino::Registry
       raise DuplicateSetting, "#{setting_definition.setting_name} is already registered at #{setting_definition.key}"
     end
 
-    @setting_definitions_by_path.deep_set(setting_definition, *setting_definition.path.map(&:to_s))
+    path = setting_definition.path.map(&:to_s)
+
+    @setting_definitions_by_path.deep_set(setting_definition, *path)
+
+    register_type_specific_data(setting_definition, path)
+  end
+
+  def register_type_specific_data(setting_definition, path)
+    case setting_definition.type
+    when Fino::Settings::Select.type_identifier
+      @option_registry.register(setting_definition.options.fetch(:options, []), path)
+    end
   end
 
   def register_section(section_definition)

data/lib/fino/setting_builder.rb

@@ -23,7 +23,7 @@ class Fino::SettingBuilder
   private
 
   def deserialize_global_value(raw_value)
-    return setting_definition.options[:default] if raw_value.equal?(Fino::EMPTINESS)
+    return setting_definition.default if raw_value.equal?(Fino::EMPTINESS)
 
     deserialize(raw_value)
   end
@@ -46,6 +46,6 @@ class Fino::SettingBuilder
   end
 
   def deserialize(value)
-    setting_definition.type_class.deserialize(value)
+    setting_definition.deserialize(value)
   end
 end

data/lib/fino/settings/boolean.rb

@@ -6,11 +6,11 @@ class Fino::Settings::Boolean
   self.type_identifier = :boolean
 
   class << self
-    def serialize(value)
+    def serialize(_setting_definition, value)
       value ? "1" : "0"
     end
 
-    def deserialize(raw_value)
+    def deserialize(_setting_definition, raw_value)
       case raw_value
       when "1", 1, true, "true", "t", "yes", "y" then true
       else false

data/lib/fino/settings/float.rb

@@ -7,11 +7,11 @@ class Fino::Settings::Float
   self.type_identifier = :float
 
   class << self
-    def serialize(value)
+    def serialize(_setting_definition, value)
       value.to_s
     end
 
-    def deserialize(raw_value)
+    def deserialize(_setting_definition, raw_value)
       raw_value.to_f
     end
   end

data/lib/fino/settings/integer.rb

@@ -7,11 +7,11 @@ class Fino::Settings::Integer
   self.type_identifier = :integer
 
   class << self
-    def serialize(value)
+    def serialize(_setting_definition, value)
       value.to_s
     end
 
-    def deserialize(raw_value)
+    def deserialize(_setting_definition, raw_value)
       raw_value.to_i
     end
   end

data/lib/fino/settings/select.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+class Fino::Settings::Select
+  class Option
+    attr_reader :label, :value, :metadata
+
+    def initialize(label:, value:, metadata: {})
+      @label = label
+      @value = value
+      @metadata = metadata
+    end
+
+    def to_s
+      value.to_s
+    end
+  end
+
+  class OptionRegistry
+    using Fino::Ext::Hash
+
+    UnknownOption = Class.new(Fino::Error)
+
+    def initialize
+      @options = {}
+      @indexed_options = {}
+      @builders = {}
+    end
+
+    def register(builder, path)
+      @builders.deep_set(builder, *path)
+    end
+
+    def options(*path)
+      resolve(path)
+      @options.dig(*path.compact.map(&:to_s))
+    end
+
+    def option(value, *path)
+      resolve(path)
+      @indexed_options.dig(*path.compact.map(&:to_s)).fetch(value) do
+        raise UnknownOption, "Unknown option: #{value} for setting: #{path.compact.join('.')}"
+      end
+    end
+
+    def refreshable?(*path)
+      builder = @builders.dig(*path.compact.map(&:to_s))
+      builder.respond_to?(:call)
+    end
+
+    def refresh!(*path)
+      string_path = path.compact.map(&:to_s)
+      builder = @builders.dig(*string_path)
+
+      return unless builder.respond_to?(:call)
+
+      resolve(path, force: true)
+      @options.dig(*string_path)
+    end
+
+    private
+
+    def resolve(path, force: false)
+      string_path = path.compact.map(&:to_s)
+
+      return if !force && @options.dig(*string_path)
+
+      builder = @builders.dig(*string_path)
+      options = builder.respond_to?(:call) ? builder.call(refresh: force) : builder
+
+      @options.deep_set(options, *string_path)
+      @indexed_options.deep_set(options.index_by(&:value), *string_path)
+    end
+  end
+
+  include Fino::Setting
+
+  self.type_identifier = :select
+
+  class << self
+    def serialize(setting_definition, value)
+      Fino.registry.option_registry.option(value.value, *setting_definition.path).value
+    end
+
+    def deserialize(setting_definition, raw_value)
+      Fino.registry.option_registry.option(raw_value, *setting_definition.path)
+    end
+  end
+
+  def options
+    Fino.registry.option_registry.options(*definition.path)
+  end
+
+  def refreshable?
+    Fino.registry.option_registry.refreshable?(*definition.path)
+  end
+
+  def refresh!
+    Fino.registry.option_registry.refresh!(*definition.path)
+  end
+end

data/lib/fino/settings/string.rb

@@ -6,11 +6,11 @@ class Fino::Settings::String
   self.type_identifier = :string
 
   class << self
-    def serialize(value)
+    def serialize(_setting_definition, value)
       value
     end
 
-    def deserialize(raw_value)
+    def deserialize(_setting_definition, raw_value)
       raw_value
     end
   end

data/lib/fino/solid/adapter.rb

@@ -21,7 +21,7 @@ module Fino
       end
 
       def write(setting_definition, value, overrides, variants)
-        serialize_value = ->(raw_value) { setting_definition.type_class.serialize(raw_value) }
+        serialize_value = ->(raw_value) { setting_definition.serialize(raw_value) }
 
         data = { VALUE_KEY => serialize_value.call(value) }
 

data/lib/fino/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Fino
-  VERSION = "1.9.1"
+  VERSION = "1.10.0"
   REQUIRED_RUBY_VERSION = ">= 3.2.0"
 end

data/lib/fino.rb

@@ -47,7 +47,11 @@ module Fino
                    :settings,
                    :slice,
                    :set,
-                   :add_override
+                   :add_override,
+                   :convert,
+                   :convert!,
+                   :analyse,
+                   :reset_analysis!
 
     def library
       raise NotImplementedError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fino
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.10.0
 platform: ruby
 authors:
 - Egor Iskrenkov
@@ -33,6 +33,7 @@ files:
 - README.md
 - lib/fino-solid.rb
 - lib/fino.rb
+- lib/fino/ab_testing/analysis.rb
 - lib/fino/ab_testing/experiment.rb
 - lib/fino/ab_testing/variant.rb
 - lib/fino/ab_testing/variant_picker.rb
@@ -46,6 +47,7 @@ files:
 - lib/fino/expirator.rb
 - lib/fino/ext/hash.rb
 - lib/fino/library.rb
+- lib/fino/library/ab_testing_analysis_support.rb
 - lib/fino/library/feature_toggles_support.rb
 - lib/fino/metadata.rb
 - lib/fino/pipe.rb
@@ -61,6 +63,7 @@ files:
 - lib/fino/settings/integer.rb
 - lib/fino/settings/numeric.rb
 - lib/fino/settings/section.rb
+- lib/fino/settings/select.rb
 - lib/fino/settings/string.rb
 - lib/fino/solid.rb
 - lib/fino/solid/adapter.rb
@@ -90,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Plug & play distributed settings engine for Ruby and Rails
 test_files: []