inferno_core 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 511a1a15fdcb49bcf9a58821b087d8a42394085f6c735971857a2e45710b7269
-  data.tar.gz: 2635bf69d9662b8afbaea341348d8dbc446707c6804be1f491c555376b8e31a6
+  metadata.gz: 7789d88730cda670cc051b8d0d56d1a9d3f8fba3133628eda872eddebd57abf9
+  data.tar.gz: 7f617722c5dd12f6ed349dd474954b7af2fc499420815e4087a18af68dbe5024
 SHA512:
-  metadata.gz: 3a31b3fe1f72ff67cc2be3c8ff11d7dfd7f6c7c203e84c55b2072f205343c6c522686accc2b927088d31ade270fa127d8ad741fbced1827497f4a3d8102d9df3
-  data.tar.gz: 1bc84724a28ae55cecc8550b51143f3c2f4ff414891c8241012ca1f94e7ea20915a801d3c3616b4ab5a4667caf12f42a273f589ad2537ab13faec9aa36144c7e
+  metadata.gz: 47b1907c5b14d12b59466d131addf56ba5579e99c7ad96ed8d7e5a7de8e8b83825f4599e39f01aa9abecd263b2fb4945c8e53efc11d247fb7eb969771ede9a06
+  data.tar.gz: 04d10803787c55903e58131832b8586a5592e27608f46b17831abf30ff4ce560fed2061e9db203965f967109e393641a3d5c17a048845df8ab1b3fba664adacc

data/lib/inferno/apps/cli/evaluate.rb

@@ -1,4 +1,5 @@
 require_relative '../../../inferno/dsl/fhir_evaluation/evaluator'
+require_relative '../../../inferno/dsl/fhir_evaluation/config'
 require_relative '../../../inferno/entities'
 require_relative '../../utils/ig_downloader'
 
@@ -12,21 +13,22 @@ module Inferno
 
       def evaluate(ig_path, data_path, _log_level)
         validate_args(ig_path, data_path)
-        _ig = get_ig(ig_path)
+        ig = get_ig(ig_path)
 
-        # Rule execution, and result output below will be integrated soon.
+        check_ig_version(ig)
 
-        # if data_path
-        #   DatasetLoader.from_path(File.join(__dir__, data_path))
-        # else
-        #   ig.examples
-        # end
+        data =
+          if data_path
+            DatasetLoader.from_path(File.join(__dir__, data_path))
+          else
+            ig.examples
+          end
 
-        # config = Config.new
-        # evaluator = Inferno::DSL::FHIREvaluation::Evaluator.new(data, config)
+        evaluator = Inferno::DSL::FHIREvaluation::Evaluator.new(ig)
 
-        # results = evaluate()
-        # output_results(results, options[:output])
+        config = Inferno::DSL::FHIREvaluation::Config.new
+        results = evaluator.evaluate(data, config)
+        output_results(results, options[:output])
       end
 
       def validate_args(ig_path, data_path)
@@ -46,7 +48,7 @@ module Inferno
           cache_directory = File.join(user_package_cache, ig_path.sub('@', '#'))
           ig = Inferno::Entities::IG.from_file(cache_directory)
         else
-          Tempfile.create('package.tgz') do |temp_file|
+          Tempfile.create(['package', '.tgz']) do |temp_file|
             load_ig(ig_path, nil, { force: true }, temp_file.path)
             ig = Inferno::Entities::IG.from_file(temp_file.path)
           end
@@ -55,6 +57,14 @@ module Inferno
         ig
       end
 
+      def check_ig_version(ig)
+        versions = ig.ig_resource.fhirVersion
+
+        return unless versions.any? { |v| v > '4.0.1' }
+
+        puts '**WARNING** The selected IG targets a FHIR version higher than 4.0.1, which is not supported by Inferno.'
+      end
+
       def user_package_cache
         File.join(Dir.home, '.fhir', 'packages')
       end

data/lib/inferno/config/boot/presets.rb

@@ -22,8 +22,8 @@ Inferno::Application.register_provider(:presets) do
       end
 
     files_to_load.compact!
-    files_to_load.uniq!
     files_to_load.map! { |path| File.realpath(path) }
+    files_to_load.uniq!
 
     files_to_load.each do |path|
       presets_repo.insert_from_file(path)

data/lib/inferno/dsl/fhir_client.rb

@@ -327,6 +327,58 @@ module Inferno
         end
       end
 
+      # Fetch all resources from a paginated FHIR bundle
+      #
+      # @param resource_type [String] The expected resource type to fetch.
+      # @param bundle [FHIR::Bundle] The initial FHIR bundle to process. Defaults to `self.resource`.
+      # @param reply_handler [Proc, nil] A handler for processing replies. Optional.
+      # @param client [Symbol] Defaults to `:default`.
+      # @param max_pages [Integer] Maximum number of pages to fetch. Defaults to 20.
+      # @param additional_resource_types [Array<String>] Additional resource types acceptable in the results.
+      # @param tags [Array<String>] for request tagging. Optional.
+      #
+      # @return [Array<FHIR::Resource>] An array of fetched FHIR resources.
+      def fetch_all_bundled_resources( # rubocop:disable Metrics/CyclomaticComplexity
+        resource_type:,
+        bundle: resource,
+        reply_handler: nil,
+        client: :default,
+        max_pages: 20,
+        additional_resource_types: [],
+        tags: []
+      )
+        page_count = 1
+        resources = []
+
+        while bundle && page_count <= max_pages
+          resources += bundle.entry&.map { |entry| entry&.resource } || []
+          reply_handler&.call(response)
+
+          break if next_bundle_link(bundle).blank?
+
+          bundle = fetch_next_bundle(bundle, client, tags)
+
+          page_count += 1
+        end
+
+        valid_resource_types = [resource_type, 'OperationOutcome'].concat(additional_resource_types)
+
+        invalid_resource_types =
+          resources.reject { |entry| valid_resource_types.include? entry.resourceType }
+            .map(&:resourceType)
+            .uniq
+        if invalid_resource_types.any?
+          info "Received resource type(s) #{invalid_resource_types.join(', ')} in search bundle, " \
+               "but only expected resource types #{valid_resource_types.join(', ')}. " \
+               'This is unusual but allowed if the server believes additional resource types are relevant.'
+        end
+
+        resources
+      rescue JSON::ParserError
+        Inferno::Application[:logger].error "Could not resolve next bundle: #{next_bundle_link(bundle)}"
+        resources
+      end
+
       # @todo Make this a FHIR class method? Something like
       #   FHIR.class_for(resource_type)
       # @private
@@ -371,6 +423,20 @@ module Inferno
         Inferno::Application[:logger].error "Unable to refresh token: #{e.message}"
       end
 
+      # @private
+      def fetch_next_bundle(bundle, client, tags)
+        reply = fhir_client(client).raw_read_url(next_bundle_link(bundle))
+        store_request('outgoing', tags:) { reply }
+        return unless request.status == 200
+
+        fhir_client(client).parse_reply(FHIR::Bundle, fhir_client(client).default_format, reply)
+      end
+
+      # @private
+      def next_bundle_link(bundle)
+        bundle&.link&.find { |link| link.relation == 'next' }&.url
+      end
+
       module ClassMethods
         # @private
         def fhir_client_definitions

data/lib/inferno/dsl/fhir_evaluation/evaluation_context.rb

@@ -6,14 +6,16 @@ module Inferno
       # - The data being evaluated
       # - A summary/characterization of the data
       # - Evaluation results
+      # - A Validator instance, configured to point to the given IG
       class EvaluationContext
-        attr_reader :ig, :data, :results, :config
+        attr_reader :ig, :data, :results, :config, :validator
 
-        def initialize(ig, data, config) # rubocop:disable Naming/MethodParameterName
+        def initialize(ig, data, config, validator)
           @ig = ig
           @data = data
           @results = []
           @config = config
+          @validator = validator
         end
 
         def add_result(result)

data/lib/inferno/dsl/fhir_evaluation/evaluator.rb

@@ -6,18 +6,23 @@ require_relative 'evaluation_context'
 require_relative 'evaluation_result'
 require_relative 'dataset_loader'
 
+Dir.glob(File.join(__dir__, 'rules', '*.rb')).each do |file|
+  require_relative file
+end
+
 module Inferno
   module DSL
     module FHIREvaluation
       class Evaluator
-        attr_accessor :ig
+        attr_accessor :ig, :validator
 
-        def initialize(ig) # rubocop:disable Naming/MethodParameterName
+        def initialize(ig, validator = nil)
           @ig = ig
+          @validator = validator
         end
 
         def evaluate(data, config = Config.new)
-          context = EvaluationContext.new(@ig, data, config)
+          context = EvaluationContext.new(@ig, data, config, validator)
 
           active_rules = []
           config.data['Rule'].each do |rulename, rule_details|

data/lib/inferno/dsl/fhir_evaluation/profile_conformance_helper.rb

@@ -0,0 +1,66 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      # This module is used to decide whether a resource instantiates a given profile.
+      # Aligning resources to profiles is necessary when evaluating the comprehensiveness
+      # of the resources with respect to those profiles, unfortunately it's impossible to
+      # programmatically determine intent. (i.e, is this resource supposed to instantiate this profile?)
+      # This module offers some approaches to make that determination.
+      module ProfileConformanceHelper
+        DEFAULT_OPTIONS = {
+          considerMetaProfile: true,
+          considerValidationResults: false,
+          considerOnlyResourceType: false
+        }.freeze
+
+        # Check whether the given resource conforms to the given profile, using the given options
+        # to select which approaches are considered.
+        # Current options:
+        # - If the resource is the right resourceType
+        # - If the resource claims conformance in resource.meta.profile
+        # - If the resource validates against the profile using the FHIR validator (NOT YET IMPLEMENTED)
+        # - If the resource meets other criteria defined in the block.
+        #   As an example, the block may look for the presence of certain codes, such as LOINC "8867-4"
+        #   in an Observation category code suggests that the resource intended to conform to a "Heart Rate" profile
+        # @param resource [FHIR::Resource]
+        # @param profile [FHIR::StructureDefinition]
+        # @param options [Hash] Hash of boolean-valued options. See DEFAULT_OPTIONS for defaults and keys
+        # @param validator [Inferno::DSL::FHIRResourceValidation::Validator]
+        # @yieldparam resource [FHIR::Resource] The original resource
+        # @yieldreturn [Boolean]
+        # @return [Boolean]
+        def conforms_to_profile?(resource, profile, options = DEFAULT_OPTIONS, validator = nil) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if resource.resourceType != profile.type
+
+          return true if options[:considerOnlyResourceType]
+
+          return true if options[:considerMetaProfile] && declares_meta_profile?(resource, profile)
+
+          return true if options[:considerValidationResults] && validates_profile?(resource, profile, validator)
+
+          return true if block_given? && yield(resource)
+
+          false
+        end
+
+        # Check if the given resource claims conformance to the profile, versioned or unversioned,
+        # based on resource.meta.profile.
+        # @param resource [FHIR::Resource]
+        # @param profile [FHIR::StructureDefinition]
+        def declares_meta_profile?(resource, profile)
+          declared_profiles = resource&.meta&.profile || []
+          profile_url = profile.url
+          versioned_url = "#{profile_url}|#{profile.version}"
+
+          declared_profiles.include?(profile_url) || declared_profiles.include?(versioned_url)
+        end
+
+        # @private until implemented
+        def validates_profile?(_resource, _profile, _validator)
+          raise 'Profile validation is not yet implemented. ' \
+                'Set considerValidationResults=false.'
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/reference_extractor.rb

@@ -0,0 +1,61 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      class ReferenceExtractor
+        attr_accessor :resource_type_ids, :references
+
+        def extract_resource_type_ids(resources)
+          @resource_type_ids = Hash.new { |type, id| type[id] = [] }
+
+          resources.each do |resource|
+            resource.each_element do |value, metadata, path|
+              next unless metadata['type'] == 'id'
+              next if path.include?('contained')
+
+              type = metadata['path'].partition('.').first.downcase
+              resource_type_ids[type] << value
+            end
+          end
+
+          resource_type_ids
+        end
+
+        def extract_references(resources)
+          @references = Hash.new { |reference, id| reference[id] = [] }
+
+          resources.each do |resource|
+            extract_references_from_resource(resource)
+          end
+
+          references
+        end
+
+        def extract_references_from_resource(resource)
+          resource.each_element do |value, metadata, path|
+            if metadata['type'] == 'Reference' && !value.reference.nil?
+              if value.reference.start_with?('#')
+                next
+              elsif value.reference.include? '/'
+                add_parsed_reference(resource, value, path)
+              elsif value.reference.start_with? 'urn:uuid:'
+                references[resource.id] << { path: path, type: '', id: value.reference[9..] }
+              else
+                references[resource.id] << { path: path, type: '', id: value.reference }
+              end
+            end
+          end
+        end
+
+        def add_parsed_reference(resource, value, path)
+          type = value.reference.split('/')[-2].downcase
+          id = value.reference.split('/')[-1]
+          references[resource.id] << if resource_type_ids.key?(type)
+                                       { path: path, type: type, id: id }
+                                     else
+                                       { path: path, type: '', id: value.reference }
+                                     end
+        end
+      end
+    end
+  end
+end