rpeft 0.1.0

data/lib/rpeft/directory.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RPEFT
+  # @api private
+  module Directory
+    module_function
+
+    # Moves source to dest. An existing destination is replaced only when it contains one of the marker files,
+    # i.e. when it looks like a previously saved artifact of the same kind.
+    # Anything else is refused so that a mistyped path never deletes unrelated data.
+    def move(source, dest, replace_markers: [])
+      # A Model made from a Hugging Face Hub id has no local directory to move.
+      raise Error, "nothing to save: #{source} is not a local directory" unless File.directory?(source)
+
+      dest = File.expand_path(dest)
+      return dest if canonical(source) == canonical(dest)
+      if inside?(source, dest) || inside?(dest, source)
+        raise ConfigurationError, "cannot save #{File.expand_path(source)} to #{dest}: one directory contains the other"
+      end
+
+      if File.exist?(dest)
+        unless replaceable?(dest, replace_markers)
+          raise ConfigurationError, "destination already exists: #{dest} (RPEFT only replaces " \
+                                    'directories it previously saved; remove it or pick another path)'
+        end
+
+        FileUtils.rm_rf(dest)
+      end
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      FileUtils.mv(source, dest)
+
+      dest
+    end
+
+    # Makes dir ready to be written into, under the same rule as move: it must be missing, empty,
+    # or an artifact RPEFT saved there before.
+    def prepare(dir, markers:)
+      dir = File.expand_path(dir)
+      if File.exist?(dir) && !(File.directory?(dir) && (Dir.empty?(dir) || replaceable?(dir, markers)))
+        raise ConfigurationError, "output directory is not empty: #{dir} (RPEFT only writes into empty directories " \
+                                  'or ones it previously wrote; remove it or pick another path)'
+      end
+
+      FileUtils.mkdir_p(dir)
+      dir
+    end
+
+    def replaceable?(dest, markers)
+      markers.any? { |marker| File.exist?(File.join(dest, marker)) }
+    end
+
+    # Resolves symlinks in the part of the path that exists, so that two spellings of the same location
+    # (such as /var and /private/var on macOS) compare equal even when the last components do not exist yet.
+    def canonical(path)
+      path = File.expand_path(path)
+      return File.realpath(path) if File.exist?(path)
+
+      parent = File.dirname(path)
+      parent == path ? path : File.join(canonical(parent), File.basename(path))
+    end
+
+    def inside?(path, dir)
+      canonical(path).start_with?("#{canonical(dir).chomp(File::SEPARATOR)}#{File::SEPARATOR}")
+    end
+  end
+end

data/lib/rpeft/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RPEFT
+  class Error < StandardError; end
+
+  # Python, PyCall, or a required Python package is missing or unusable.
+  class DependencyError < Error; end
+
+  # Invalid options were passed to the Ruby API.
+  class ConfigurationError < Error; end
+
+  # The dataset file is missing or not in the expected JSONL format.
+  class DatasetError < Error; end
+
+  # The base model or an adapter directory could not be loaded.
+  class ModelLoadError < Error; end
+
+  # LoRA training failed. The original Python error is available via #cause.
+  class TrainingError < Error; end
+
+  # Merging the adapter into the base model failed.
+  class MergeError < Error; end
+
+  # Text generation failed.
+  class GenerationError < Error; end
+end

data/lib/rpeft/generation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RPEFT
+  # @api private
+  #
+  # Shared request building for text generation. Model#generate runs
+  # a standalone model; Adapter#generate adds adapter_path so the backend
+  # applies the adapter on top of the base model without merging.
+  #
+  # Exactly one of prompt: and messages: is given. With messages: the backend renders
+  # the transcript with the tokenizer's chat template before generating.
+  module Generation
+    module_function
+
+    def run(model:, prompt: nil, messages: nil, max_new_tokens: 64, device: :auto, temperature: nil, top_p: nil, seed: nil, adapter_path: nil)
+      # Everything is validated before Device.resolve, which reaches the backend:
+      # a bad argument should not cost a Python round trip.
+      validate(max_new_tokens, temperature, top_p, seed)
+      input = input_for(prompt, messages)
+
+      request = {
+        'model' => model,
+        'max_new_tokens' => max_new_tokens,
+        'device' => Device.resolve(device).to_s,
+        'trust_remote_code' => false
+      }.merge(input)
+      request['adapter_path'] = adapter_path if adapter_path
+      request['temperature'] = temperature if temperature
+      request['top_p'] = top_p if top_p
+      request['seed'] = seed if seed
+
+      RPEFT.backend.generate(request)['completion']
+    end
+
+    def input_for(prompt, messages)
+      unless messages
+        return {'prompt' => prompt} if prompt.is_a?(String) && !prompt.empty?
+
+        raise ConfigurationError, "prompt must be a non-empty String, got #{prompt.inspect}"
+      end
+      return {'messages' => messages} if Messages.valid?(messages)
+
+      raise ConfigurationError, "messages must be a non-empty Array of Hashes with a role of system, user, or assistant and String content, got #{messages.inspect}"
+    end
+
+    def validate(max_new_tokens, temperature, top_p, seed)
+      if !max_new_tokens.is_a?(Integer) || !max_new_tokens.positive?
+        raise ConfigurationError, "max_new_tokens must be a positive Integer, got #{max_new_tokens.inspect}"
+      end
+
+      if temperature && !(temperature.is_a?(Numeric) && temperature.positive?)
+        raise ConfigurationError, "temperature must be a positive number, got #{temperature.inspect}"
+      end
+
+      if top_p && !(top_p.is_a?(Numeric) && top_p.positive? && top_p <= 1)
+        raise ConfigurationError, "top_p must be within (0.0, 1.0], got #{top_p.inspect}"
+      end
+      return if seed.nil? || seed.is_a?(Integer)
+
+      raise ConfigurationError, "seed must be an Integer, got #{seed.inspect}"
+    end
+  end
+end

data/lib/rpeft/lora/adapter.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'tmpdir'
+
+module RPEFT
+  module LoRA
+    # A trained LoRA adapter directory: the learned B A matrices plus the configuration
+    # and metadata needed to merge them back into the base model.
+    class Adapter
+      METADATA_FILE = 'rpeft_metadata.json'
+      PEFT_CONFIG_FILE = 'adapter_config.json'
+      # Where the backend keeps checkpoints while training; see python/rpeft_backend/_training.py.
+      TRAINER_DIR = '.trainer'
+      REPLACE_MARKERS = [METADATA_FILE, PEFT_CONFIG_FILE].freeze
+
+      attr_reader :path, :base_model, :rank, :alpha, :dropout, :target_modules, :metadata
+
+      class << self
+        def load(path, base_model: nil)
+          dir = File.expand_path(Arguments.path(path, 'path'))
+          base_model = Arguments.model(base_model, 'base_model') if base_model
+          metadata_file = File.join(dir, METADATA_FILE)
+          peft_file = File.join(dir, PEFT_CONFIG_FILE)
+
+          if File.file?(metadata_file)
+            from_metadata(dir, parse_json(metadata_file), base_model)
+          elsif File.file?(peft_file)
+            from_peft_config(dir, parse_json(peft_file), base_model)
+          else
+            raise ModelLoadError, "#{dir} is not a LoRA adapter directory (no #{METADATA_FILE} or #{PEFT_CONFIG_FILE} found)"
+          end
+        end
+
+        private
+
+        def from_metadata(dir, metadata, base_model)
+          lora = metadata['lora'] || {}
+          new(
+            path: dir,
+            base_model: base_model || metadata['base_model'],
+            rank: lora['rank'],
+            alpha: lora['alpha'],
+            dropout: lora['dropout'],
+            target_modules: lora['target_modules'],
+            metadata: metadata
+          )
+        end
+
+        # Fallback for adapter directories produced by plain PEFT,
+        # which have no rpeft_metadata.json.
+        def from_peft_config(dir, config, base_model)
+          new(
+            path: dir,
+            base_model: base_model || config['base_model_name_or_path'],
+            rank: config['r'],
+            alpha: config['lora_alpha'],
+            dropout: config['lora_dropout'],
+            target_modules: config['target_modules'],
+            metadata: {}
+          )
+        end
+
+        def parse_json(file)
+          JSON.parse(File.read(file))
+        rescue JSON::ParserError => e
+          raise ModelLoadError, "failed to parse #{file}: #{e.message}"
+        end
+      end
+
+      def initialize(path:, base_model:, rank: nil, alpha: nil, dropout: nil, target_modules: nil, metadata: {})
+        @path = File.expand_path(path)
+        @base_model = base_model
+        @rank = rank
+        @alpha = alpha
+        @dropout = dropout
+        @target_modules = target_modules
+        @metadata = metadata.freeze
+      end
+
+      def save(dest)
+        @path = Directory.move(@path, Arguments.path(dest, 'dest'), replace_markers: REPLACE_MARKERS)
+        self
+      end
+
+      # Merges the learned B A update into the base model weights
+      # (W = W0 + B A) and returns the resulting standalone Model.
+      def merge(output_dir: nil)
+        unless base_model
+          raise MergeError, 'base model is unknown; pass base_model: to Adapter.load ' \
+                            '(or --model to the CLI)'
+        end
+
+        output_dir = Arguments.path(output_dir, 'output_dir') if output_dir
+        empty_dir = output_dir && File.directory?(output_dir) && Dir.empty?(output_dir)
+        fresh = output_dir.nil? || !File.exist?(output_dir) || empty_dir
+        merged_dir = output_dir ? Directory.prepare(output_dir, markers: Model::REPLACE_MARKERS) : Dir.mktmpdir('rpeft-merged-')
+        result = RPEFT.backend.merge_lora(
+          'adapter_path' => path,
+          'output_dir' => merged_dir,
+          'base_model' => base_model
+        )
+
+        model_dir = result['model_path'] || merged_dir
+        merged_base_model = result['base_model'] || base_model
+        FileUtils.mkdir_p(model_dir)
+        Model.write_metadata(model_dir, base_model: merged_base_model)
+
+        Model.new(path: model_dir, base_model: merged_base_model)
+      rescue StandardError
+        # A partial merge has weights but no marker, which would make Directory.prepare refuse the retry.
+        # Only what this merge created is removed; a model merged there before keeps its marker.
+        discard_partial_merge(merged_dir, keep_dir: empty_dir) if merged_dir && fresh
+        raise
+      end
+
+      # Generates with the adapter applied on top of the base model, without merging.
+      # Useful for verifying an adapter before producing a merged model.
+      def generate(prompt, max_new_tokens: 64, device: :auto, temperature: nil, top_p: nil, seed: nil)
+        require_base_model
+
+        Generation.run(
+          model: base_model,
+          prompt: prompt,
+          adapter_path: path,
+          max_new_tokens: max_new_tokens,
+          device: device,
+          temperature: temperature,
+          top_p: top_p,
+          seed: seed
+        )
+      end
+
+      # Continues a chat transcript with the adapter applied on top of the base model.
+      def chat(messages, max_new_tokens: 64, device: :auto, temperature: nil, top_p: nil, seed: nil)
+        require_base_model
+
+        Generation.run(
+          model: base_model,
+          messages: messages,
+          adapter_path: path,
+          max_new_tokens: max_new_tokens,
+          device: device,
+          temperature: temperature,
+          top_p: top_p,
+          seed: seed
+        )
+      end
+
+      private
+
+      # An adapter is a delta against specific base weights, so it cannot be applied without knowing which model it belongs to.
+      def require_base_model
+        return if base_model
+
+        raise GenerationError, 'base model is unknown; pass base_model: to Adapter.load (or --model to the CLI)'
+      end
+
+      def discard_partial_merge(dir, keep_dir:)
+        if keep_dir
+          Dir.children(dir).each do |child|
+            FileUtils.rm_rf(File.join(dir, child))
+          end
+        else
+          FileUtils.rm_rf(dir)
+        end
+      end
+    end
+  end
+end

data/lib/rpeft/lora.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'time'
+require 'tmpdir'
+
+module RPEFT
+  # LoRA fine-tuning. Keeps the base model weights W0 frozen and learns
+  # a low-rank update delta W ~= B A of rank r:
+  #
+  #   W = W0 + B A
+  #
+  # The `rank:` option is exactly that r.
+  module LoRA
+    POSITIVE_INTEGER_OPTIONS = %i(rank epochs batch_size max_length).freeze
+    POSITIVE_NUMBER_OPTIONS = %i(alpha learning_rate).freeze
+
+    class << self
+      def train(model:, dataset:, eval_dataset: nil, rank: 8, alpha: 16, dropout: 0.05, target_modules: nil, epochs: 3, batch_size: 4, learning_rate: 2e-4, max_length: 512, output_dir: nil, device: :auto, checkpoints: false, resume: false)
+        options = {
+          rank: rank,
+          alpha: alpha,
+          dropout: dropout,
+          target_modules: target_modules,
+          epochs: epochs,
+          batch_size: batch_size,
+          learning_rate: learning_rate,
+          max_length: max_length,
+          checkpoints: checkpoints,
+          resume: resume
+        }
+        model = Arguments.model(model, 'model')
+        output_dir = Arguments.path(output_dir, 'output_dir') if output_dir
+        validate_options(options)
+        validate_resume(resume, output_dir)
+        training_dataset = Dataset.coerce(dataset)
+        evaluation_dataset = coerce_eval_dataset(eval_dataset, training_dataset)
+        adapter_dir = prepare_output_dir(output_dir)
+        resolved_device = Device.resolve(device)
+
+        options[:eval_dataset] = evaluation_dataset
+        result = RPEFT.backend.train_lora(
+          request_payload(model, training_dataset, adapter_dir, resolved_device, options)
+        )
+
+        build_adapter(
+          adapter_dir: adapter_dir,
+          model: model,
+          dataset_name: training_dataset.name,
+          device: resolved_device,
+          options: options,
+          result: result
+        )
+      rescue StandardError
+        # A temporary directory is never returned to the caller, so a failed run leaves nothing anyone could
+        # resume from. An explicit output_dir is kept for resume: true.
+        FileUtils.rm_rf(adapter_dir) if adapter_dir && output_dir.nil?
+        raise
+      ensure
+        # Datasets given as Dataset objects belong to the caller and may be reused for another run.
+        training_dataset.discard if training_dataset && !training_dataset.equal?(dataset)
+        evaluation_dataset.discard if evaluation_dataset && !evaluation_dataset.equal?(eval_dataset)
+      end
+
+      private
+
+      def validate_options(options)
+        POSITIVE_INTEGER_OPTIONS.each do |key|
+          value = options[key]
+          if !value.is_a?(Integer) || !value.positive?
+            raise ConfigurationError, "#{key} must be a positive Integer, got #{value.inspect}"
+          end
+        end
+        POSITIVE_NUMBER_OPTIONS.each do |key|
+          value = options[key]
+          if !value.is_a?(Numeric) || !value.positive?
+            raise ConfigurationError, "#{key} must be a positive number, got #{value.inspect}"
+          end
+        end
+        validate_dropout(options[:dropout])
+        validate_target_modules(options[:target_modules])
+      end
+
+      def validate_dropout(dropout)
+        return if dropout.is_a?(Numeric) && dropout >= 0 && dropout < 1
+
+        raise ConfigurationError, "dropout must be a number within 0.0...1.0, got #{dropout.inspect}"
+      end
+
+      def validate_target_modules(target_modules)
+        return if target_modules.nil?
+        return if target_modules.is_a?(Array) && !target_modules.empty? && target_modules.all?(String)
+
+        raise ConfigurationError, "target_modules must be nil (auto) or a non-empty Array of Strings, got #{target_modules.inspect}"
+      end
+
+      # Without an explicit output_dir every run gets a fresh temporary directory, so there would never be a checkpoint of an earlier run to resume from.
+      def validate_resume(resume, output_dir)
+        return if !resume || !output_dir.nil?
+
+        raise ConfigurationError, 'resume: true requires an explicit output_dir: to find the previous checkpoints'
+      end
+
+      # The backend tokenizes both datasets the same way, so mixing formats would silently mis-render the evaluation set.
+      def coerce_eval_dataset(eval_dataset, training_dataset)
+        return nil unless eval_dataset
+
+        dataset = Dataset.coerce(eval_dataset)
+        return dataset if dataset.backend_format == training_dataset.backend_format
+
+        # Raised before train assigns the dataset, so its ensure clause cannot discard it.
+        dataset.discard unless dataset.equal?(eval_dataset)
+        raise ConfigurationError, "eval_dataset format (#{dataset.format}) must match dataset format (#{training_dataset.format})"
+      end
+
+      def prepare_output_dir(output_dir)
+        return Dir.mktmpdir('rpeft-adapter-') unless output_dir
+
+        # TRAINER_DIR marks a run that stopped before saving the adapter, which resume: true picks up.
+        Directory.prepare(output_dir, markers: [*Adapter::REPLACE_MARKERS, Adapter::TRAINER_DIR])
+      end
+
+      def request_payload(model, dataset, adapter_dir, device, options)
+        payload = {
+          'base_model' => model,
+          'dataset_path' => dataset.path,
+          'dataset_format' => dataset.backend_format,
+          'output_dir' => adapter_dir,
+          'text_field' => 'text',
+          'device' => device.to_s,
+          'max_length' => options[:max_length],
+          'epochs' => options[:epochs],
+          'batch_size' => options[:batch_size],
+          'learning_rate' => options[:learning_rate],
+          'logging_steps' => 5,
+          'seed' => 42,
+          'trust_remote_code' => false,
+          'save_strategy' => options[:checkpoints] ? 'epoch' : 'no',
+          'resume_from_checkpoint' => options[:resume],
+          'lora' => {
+            'r' => options[:rank],
+            'alpha' => options[:alpha],
+            'dropout' => options[:dropout],
+            'target_modules' => options[:target_modules]
+          }
+        }
+        payload['eval_dataset_path'] = options[:eval_dataset].path if options[:eval_dataset]
+
+        payload
+      end
+
+      def build_adapter(adapter_dir:, model:, dataset_name:, device:, options:, result:)
+        target_modules = result.dig('effective_config', 'lora', 'target_modules') || options[:target_modules]
+        metadata = build_metadata(
+          model: model,
+          dataset_name: dataset_name,
+          device: device,
+          options: options,
+          target_modules: target_modules,
+          result: result
+        )
+        File.write(File.join(adapter_dir, Adapter::METADATA_FILE), "#{JSON.pretty_generate(metadata)}\n")
+
+        Adapter.new(
+          path: adapter_dir,
+          base_model: model,
+          rank: options[:rank],
+          alpha: options[:alpha],
+          dropout: options[:dropout],
+          target_modules: target_modules,
+          metadata: metadata
+        )
+      end
+
+      def build_metadata(model:, dataset_name:, device:, options:, target_modules:, result:)
+        {
+          'schema_version' => 1,
+          'rpeft_version' => VERSION,
+          'kind' => 'lora_adapter',
+          'base_model' => model,
+          'created_at' => Time.now.iso8601,
+          'lora' => {
+            'rank' => options[:rank],
+            'alpha' => options[:alpha],
+            'dropout' => options[:dropout],
+            'target_modules' => target_modules
+          },
+          'training' => {
+            'dataset' => dataset_name,
+            'epochs' => options[:epochs],
+            'batch_size' => options[:batch_size],
+            'learning_rate' => options[:learning_rate],
+            'max_length' => options[:max_length],
+            'device' => result['device'] || device.to_s,
+            'train_loss' => result['final_loss'],
+            'eval_loss' => result['eval_loss'],
+            'duration_seconds' => result['train_runtime_seconds']
+          }
+        }
+      end
+    end
+  end
+end

data/lib/rpeft/messages.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RPEFT
+  # @api private
+  #
+  # Shape check for a chat transcript, shared by the dataset reader and the chat API.
+  # Only the predicate is shared: each caller raises the error that fits its context.
+  # String and Symbol keys are both accepted, since transcripts read from JSONL have
+  # String keys while ones written in Ruby naturally have Symbol keys.
+  module Messages
+    # Chat templates write the role into the prompt as is, and some drop turns whose role they do not know,
+    # so only the roles every template understands are accepted.
+    ROLES = %w(system user assistant).freeze
+
+    module_function
+
+    def valid?(messages)
+      return false if !messages.is_a?(Array) || messages.empty?
+
+      messages.all? { |message|
+        next false unless message.is_a?(Hash)
+
+        role = message['role'] || message[:role]
+        content = message['content'] || message[:content]
+
+        ROLES.include?(role) && content.is_a?(String)
+      }
+    end
+  end
+end

data/lib/rpeft/model.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module RPEFT
+  # A full model: either a local directory (typically the result of merging a LoRA adapter)
+  # or a Hugging Face Hub model id.
+  class Model
+    METADATA_FILE = 'rpeft_metadata.json'
+    # Not config.json: it is a common name outside model directories, and a mistyped save destination
+    # holding one would otherwise be deleted.
+    REPLACE_MARKERS = [METADATA_FILE].freeze
+
+    attr_reader :path, :base_model
+
+    # Marks dir as a merged model saved by RPEFT, which is what lets a later #save replace it.
+    def self.write_metadata(dir, base_model:)
+      metadata = {
+        'schema_version' => 1,
+        'rpeft_version' => VERSION,
+        'kind' => 'merged_model',
+        'base_model' => base_model,
+        'created_at' => Time.now.iso8601
+      }
+      File.write(File.join(dir, METADATA_FILE), "#{JSON.pretty_generate(metadata)}\n")
+    end
+
+    def initialize(path:, base_model: nil)
+      path = Arguments.path(path, 'path')
+      # A Hub id such as "Qwen/Qwen2.5-Coder-0.5B" must stay verbatim; only real local directories are expanded.
+      @path = File.directory?(path) ? File.expand_path(path) : path
+      @base_model = base_model
+    end
+
+    def save(dest)
+      @path = Directory.move(@path, Arguments.path(dest, 'dest'), replace_markers: REPLACE_MARKERS)
+      self
+    end
+
+    # Generates a completion for the prompt. Decoding is greedy (and thus deterministic for a given model and prompt)
+    # unless temperature or top_p turns sampling on.
+    def generate(prompt, max_new_tokens: 64, device: :auto, temperature: nil, top_p: nil, seed: nil)
+      Generation.run(
+        model: path,
+        prompt: prompt,
+        max_new_tokens: max_new_tokens,
+        device: device,
+        temperature: temperature,
+        top_p: top_p,
+        seed: seed
+      )
+    end
+
+    # Continues a chat transcript and returns the assistant's reply. The transcript is
+    # rendered with the model's own chat template, which is what a model fine-tuned on
+    # chat-format data expects to see.
+    def chat(messages, max_new_tokens: 64, device: :auto, temperature: nil, top_p: nil, seed: nil)
+      Generation.run(
+        model: path,
+        messages: messages,
+        max_new_tokens: max_new_tokens,
+        device: device,
+        temperature: temperature,
+        top_p: top_p,
+        seed: seed
+      )
+    end
+  end
+end

data/lib/rpeft/version.rb

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

data/lib/rpeft.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'rpeft/version'
+require_relative 'rpeft/errors'
+require_relative 'rpeft/arguments'
+require_relative 'rpeft/device'
+require_relative 'rpeft/directory'
+require_relative 'rpeft/dataset'
+require_relative 'rpeft/messages'
+require_relative 'rpeft/generation'
+require_relative 'rpeft/model'
+require_relative 'rpeft/lora'
+require_relative 'rpeft/lora/adapter'
+require_relative 'rpeft/backend'
+require_relative 'rpeft/diagnosis'
+
+module RPEFT
+  DEVICES = %i(cuda mps cpu).freeze
+
+  class << self
+    # The backend seam. Assign a fake in tests; assign nil to restore the default PyCall-based backend.
+    attr_writer :backend
+
+    def backend
+      @backend ||= Backend.default
+    end
+
+    # The compute device that training will use, preferring CUDA over MPS over CPU.
+    def device
+      backend.detect_device({})['device'].to_sym
+    end
+
+    def check
+      Diagnosis.new(backend: backend).report
+    end
+  end
+end