test-patient-generator 1.0.0

data/lib/tpg/ext/record.rb

@@ -0,0 +1,6 @@
+# Extensions to the Record model in health-data-standards to add needed functionality for test patient generation
+class Record
+  field :type, type: String
+  field :measure_ids, type: Array
+  field :source_data_criteria, type: Array
+end

data/lib/tpg/ext/subset_operator.rb

@@ -0,0 +1,7 @@
+module HQMF
+  class SubsetOperator
+    def generate(base_patients)
+      
+    end
+  end
+end

data/lib/tpg/ext/temporal_reference.rb

@@ -0,0 +1,66 @@
+module HQMF
+  # Generates a Range to define the timing of a data_criteria
+  class TemporalReference
+    # 
+    #
+    # @param [Array] base_patients
+    # @return 
+    def generate(base_patients)
+      if reference.id == "MeasurePeriod"
+        matching_time = Generator::hqmf.measure_period.clone
+      else
+        # First generate patients for the data criteria that this temporal reference points to
+        data_criteria = Generator::hqmf.data_criteria(reference.id)
+        base_patients = data_criteria.generate(base_patients)
+
+        # Now that the data criteria is defined, we can set our relative time to those generated results
+        matching_time = data_criteria.generation_range.first.clone
+      end
+      
+      # TODO add nils where necessary. Ranges should be unbounded, despite the relative time's potential bounds (unless the type specifies)
+      if range
+        offset = range.try(:clone)
+        
+        case type
+        when "DURING"
+          # TODO differentiate between this and CONCURRENT
+        when "SBS" # Starts before start
+          offset.low.value.insert(0, "-")
+        when "SAS" # Starts after start
+          offset.low = offset.high
+          offset.high = nil
+        when "SBE" # Starts before end
+          offset.low = offset.high
+          offset.high = nil
+          offset.low.value.insert(0, "-")
+          matching_time.low = matching_time.high
+        when "SAE" # Starts after end
+          
+        when "EBS" # Ends before start
+
+        when "EAS" # Ends after start
+
+        when "EBE" # Ends before end
+
+        when "EAE" # Ends after end
+
+        when "SDU" # Starts during
+          matching_time.high.value = nil
+        when "EDU" # Ends during
+
+        when "ECW" # Ends concurrent with
+
+        when "SCW" # Starts concurrent with
+
+        when "CONCURRENT"
+
+        end
+        
+        matching_time = Range.merge_ranges(offset, matching_time)
+      end
+      
+      # Note we return the possible times to the calling data criteria, not patients
+      [matching_time]
+    end
+  end
+end

data/lib/tpg/ext/value.rb

@@ -0,0 +1,112 @@
+module HQMF
+  class Value
+    include Comparable
+    
+    # Perform a deep copy of this Value.
+    #
+    # @return A deep copy of this Value.
+    def clone
+      Value.new(type.try(:clone), unit.try(:clone), value.try(:clone), inclusive?, derived?, expression.try(:clone))
+    end
+
+    #
+    def format      
+      unit_mapping = {"a" => "years", "mo" => "months", "wk" => "weeks", "d" => "days"}
+      pretty_unit = unit_mapping[unit] if unit
+      pretty_unit ||= unit
+      
+      { "scalar" => value, "units" => pretty_unit }
+    end
+
+    # 
+    #
+    # @param [Value] value1
+    # @param [Value] value2
+    # @return 
+    def self.merge_values(value1, value2)
+      # If only one value in the range is defined, we have no work to do
+      return value1 if value2.nil?
+      return value2 if value1.nil?
+      
+      if value1.type == "PQ" && value2.type == "PQ"
+        # TODO Combine the value of two PQs. This will be tough if there is a case of time units and no relative TS
+        
+      elsif value1.type == "TS" && value2.type == "TS"
+        # Convert the time strings that we have into actual time objects
+        
+      else
+        # One PQ and one TS
+        pq = value1.type == "PQ" ? value1 : value2
+        ts = value1.type == "TS" ? value1 : value2
+        
+        # Create a Ruby object to represent the TS
+        year = ts.value[0,4]
+        month = ts.value[4,2]
+        day = ts.value[6,2]
+        time = Time.new(year, month, day)
+        
+        # Advance that time forward the amount the PQ specifies. Convert units to symbols for advance function.
+        pq.value += 1 unless pq.inclusive?
+        unit_mapping = {"a" => :years, "mo" => :months, "wk" => :weeks, "d" => :days}
+        time = time.advance({unit_mapping[pq.unit] => pq.value.to_i})
+        
+        # Form up the modified TS with expected YYYYMMDD formatting (avoid YYYYMD)
+        year = time.year
+        month = time.month < 10 ? "0#{time.month}" : time.month
+        day = time.day < 10 ? "0#{time.day}" : time.day
+        
+        Value.new("TS", value1.unit, "#{year}#{month}#{day}", value1.inclusive? && value2.inclusive?, false, false)
+      end
+    end
+    
+    def self.time_to_ts(time)
+      year = time.year
+      month = time.month < 10 ? "0#{time.month}" : time.month
+      day = time.day < 10 ? "0#{time.day}" : time.day
+      
+      "#{year}#{month}#{day}"
+    end
+    
+    #
+    #
+    # @return
+    def to_seconds
+      to_time_object.to_i
+    end
+    
+    # 
+    #
+    # @return 
+    def to_time_object
+      year = value[0,4].to_i
+      month = value[4,2].to_i
+      day = value[6,2].to_i
+      hour = 0
+      minute = 0
+      second = 0
+      if (value.length > 8)
+        hour = value[8,2].to_i
+        minute = value[10,2].to_i
+        second = value[12,2].to_i
+      end
+      
+      Time.new(year, month, day, hour, minute, second)
+    end
+    
+    def <=>(value)
+      # So far there has only been a need to compare TS Values
+      if type == "TS" && value.type == "TS"
+        time = to_time_object
+        other = value.value
+        
+        if time < other
+          -1
+        elsif time > other
+          1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/tpg/generation/exporter.rb

@@ -0,0 +1,118 @@
+module TPG
+  class Exporter
+    # Export a list of patients to a zip file. Contains nothing but patient records.
+    #
+    # @param [Array] patients All of the patients that will be exported.
+    # @param [String] format The desired format for the patients to be in.
+    # @return A zip file containing all given patients in the requested format.
+    def self.zip(patients, format, concept_map=nil)
+      file = Tempfile.new("patients-#{Time.now.to_i}")
+      
+      Zip::ZipOutputStream.open(file.path) do |z|
+        xslt = Nokogiri::XSLT(File.read("public/cda.xsl"))
+        patients.each do |patient|
+          next_entry_path = patient_filename(patient)
+
+          if format == "c32"
+            z.put_next_entry("#{next_entry_path}.xml")
+            z << HealthDataStandards::Export::C32.export(patient)
+          elsif format == "ccr"
+            z.put_next_entry("#{next_entry_path}.xml")
+            z << HealthDataStandards::Export::CCR.export(patient)
+          elsif format == "ccda"
+            z.put_next_entry("#{next_entry_path}.xml")
+            z << HealthDataStandards::Export::CCDA.export(patient)
+          elsif format == "html"
+            z.put_next_entry("#{next_entry_path}.html")
+            z << html_contents(patient, concept_map)
+          elsif format == "json"
+            z.put_next_entry("#{next_entry_path}.json")
+            z << JSON.pretty_generate(JSON.parse(patient.to_json))
+          end
+        end
+      end
+      
+      file.close
+      file
+    end
+    
+    # Export QRDA Category 1 patients to a zip file. Contents are organized with a directory for each measure containing one patient for validation.
+    #
+    # @param [Hash] measure_patients Measures mapped to the patient that was generated for it.
+    # @return A zip file containing all of the QRDA Category 1 patients that were passed in.
+    def self.zip_qrda_patients(measure_patients)
+      file = Tempfile.new("patients-#{Time.now.to_i}")
+      
+      Zip::ZipOutputStream.open(file.path) do |zip|
+        xslt = Nokogiri::XSLT(File.read("public/cda.xsl"))
+        measure_patients.each do |measure, patient|
+          # Create a directory for this measure and insert the HTML for this patient.
+          zip.put_next_entry(File.join(measure, "#{patient_filename(patient)}.html"))
+          zip << html_contents(patient)
+        end
+      end
+      
+      file.close
+      file
+    end
+    
+    # Export a list of patients to a zip file. Contains the proper formatting of a patient bundle for Cypress,
+    # i.e. a bundle JSON file with four subdirectories for c32, ccr, html, and JSON formatting for patients.
+    #
+    # @param [Array] patients All of the patients that will be exported.
+    # @param [String] version The version to mark the bundle.json file of this archive.
+    # @return A bundle containing all of the QRDA Category 1 patients that were passed in.
+    def self.zip_bundle(patients, name, version)
+      file = Tempfile.new("patients-#{Time.now.to_i}")
+      
+      Zip::ZipOutputStream.open(file.path) do |zip|
+        # Generate the bundle file
+        zip.put_next_entry("bundle.json")
+        zip << {name: name, version: version}.to_json
+        
+        xslt = Nokogiri::XSLT(File.read("public/cda.xsl"))
+        patients.each_with_index do |patient, index|
+          filename = "#{index}_#{patient_filename(patient)}"
+          
+          # Define path names
+          c32_path = File.join("patients", "c32", "#{filename}.xml")
+          ccr_path = File.join("patients", "ccr", "#{filename}.xml")
+          html_path = File.join("patients", "html", "#{filename}.html")
+          json_path = File.join("patients", "json", "#{filename}.json")
+          
+          # For each patient add a C32, CCR, HTML, and JSON file.
+          zip.put_next_entry(c32_path)
+          zip << HealthDataStandards::Export::C32.export(patient)
+          zip.put_next_entry(ccr_path)
+          zip << HealthDataStandards::Export::CCR.export(patient)
+          zip.put_next_entry(html_path)
+          zip << html_contents(patient)
+          zip.put_next_entry(json_path)
+          zip << JSON.pretty_generate(JSON.parse(patient.to_json))
+        end
+      end
+      
+      file.close
+      file
+    end
+    
+    # Generate the HTML output for a Record from Health Data Standards.
+    #
+    # @param [Record] patient The Record for which we're generating HTML content.
+    # @return HTML content to be exported for a Record.
+    def self.html_contents(patient, concept_map=nil)
+      HealthDataStandards::Export::HTML.export(patient, concept_map)
+    end
+    
+    # Join the first and last name with an underscore and replace any other punctuation that might interfere with file names.
+    #
+    # @param [Record] patient The patient for whom we're generating a filename.
+    # @return A string that can be used safely as a filename.
+    def self.patient_filename(patient)
+      safe_first_name = patient.first.gsub("'", "")
+      safe_last_name = patient.last.gsub("'", "")
+      
+      "#{safe_first_name}_#{safe_last_name}"
+    end
+  end
+end

data/lib/tpg/generation/generator.rb

@@ -0,0 +1,169 @@
+module HQMF
+  # The generator will create as many patients as possible to exhaustively test the logic of a given clinical quality measure.
+  class Generator
+    # TODO - This is a hack and a half. Need a better way to resolve data_criteria from any point in the tree.
+    class << self
+      attr_accessor :hqmf
+      attr_accessor :value_sets
+    end
+    
+    # @param [HQMF::Document] hqmf A model representing the logic of a given HQMF document.
+    # @param [Hash] value_sets All of the value sets referenced by this particular HQMF document.
+    def initialize(hqmf, value_sets)
+      @patients = []
+      Generator.hqmf = hqmf
+      Generator.value_sets = value_sets
+    end
+    
+    # Generate patients from lists of DataCriteria. This is originally created for QRDA Category 1 validation testing,
+    # i.e. a single patient will be generated per measure with an entry for every data criteria involved in the measure.
+    # 
+    # @param [Hash] measure_needs A hash of measure IDs mapped to a list of all their data criteria.
+    # @param [Hash] measure_value_sets A hash of measure IDs mapped to hashes of value sets used by the DataCriteria in measure_needs.
+    # @return [Hash] A hash of measure IDs mapped to a Record that includes all the given data criteria (values and times are arbitrary).
+    def self.generate_qrda_patients(measure_needs, measure_value_sets)
+      return {} if measure_needs.nil?
+      
+      measure_patients = {}
+      measure_needs.each do |measure, all_data_criteria|
+        # Prune out all data criteria that create similar entries. Category 1 validation is only checking for ability to access information
+        # so to minimize time we only want to include each kind of data once.
+        unique_data_criteria = []
+        all_data_criteria.each do |data_criteria|
+          index = unique_data_criteria.index {|dc| dc.code_list_id == data_criteria.code_list_id && dc.negation_code_list_id == data_criteria.negation_code_list_id && dc.field_values == data_criteria.field_values && dc.status == data_criteria.status}
+          unique_data_criteria << data_criteria if index.nil?
+        end
+        
+        # Create a patient that includes an entry for every data criteria included in this measure.
+        patient = Generator.create_base_patient
+        unique_data_criteria.each do |data_criteria|
+          # Ignore data criteria that are really just containers.
+          next if data_criteria.derivation_operator.present?
+          
+          # Generate a random time for this data criteria and apply it to the patient.
+          time = Randomizer.randomize_range(patient.birthdate, nil)
+          data_criteria.modify_patient(patient, time, measure_value_sets[measure])
+        end
+        patient.measure_ids ||= []
+        patient.measure_ids << measure
+        patient.type = "qrda"
+        measure_patients[measure] = Generator.finalize_patient(patient)
+      end
+      
+      measure_patients
+    end
+    
+    # Generate patients from an HQMF file and its matching value sets file. These patients are designed to test all
+    # paths through the logic of this particular clinical quality measure.
+    def generate_patients
+      base_patients = [Generator.create_base_patient]
+      generated_patients = []
+      
+      # Gather all available populations. Each kind of population (e.g. IPP, DENOM) can have many multiples (e.g. IPP_1, IPP_2)
+      populations = []
+      ["IPP", "DENOM", "NUMER", "EXCL", "DENEXCEP"].each do |population|
+        i = 1
+        populations << population
+        while Generator.hqmf.population_criteria("#{population}_#{i}").present? do
+          populations << "#{population}_#{i}"
+          i += 1
+        end
+      end
+
+      populations = ["EXCL_1"]
+
+      populations.each do |population|
+        criteria = Generator.hqmf.population_criteria(population)
+        
+        # We don't need to do anything for populations with nothing specified
+        next if criteria.nil? || !criteria.preconditions.present?
+        criteria.generate(base_patients)  
+        
+        # Mark the patient we just created with its expected population. Then extend the Record to be augmented by the next population.
+        base_patients.collect! do |patient|
+          generated_patients.push(Generator.finalize_patient(patient))
+          Generator.extend_patient(patient)
+        end
+      end
+      
+      generated_patients
+    end
+    
+    # Create a patient with trivial demographic information and no coded entries.
+    #
+    # @return A Record with a blank slate
+    def self.create_base_patient(initial_attributes = nil)
+      patient = Record.new
+      
+      if initial_attributes.nil?
+        patient = Randomizer.randomize_demographics(patient)
+      else
+        initial_attributes.each {|attribute, value| patient.send("#{attribute}=", value)}
+      end
+      patient.medical_record_number = "#{patient.first} #{patient.last}".hash.abs
+      
+      patient
+    end
+    
+    # Take an existing patient with some coded entries on them and redefine their trivial demographic information
+    #
+    # @param [Record] base_patient The patient that we're using as a base to create a new one
+    # @return A new Record with an identical medical history to the given patient but new trivial demographic information
+    def self.extend_patient(base_patient)
+      patient = base_patient.clone()
+      Randomizer.randomize_demographics(patient)
+    end
+    
+    # Fill in any missing details that should be filled in on a patient. These include: age, gender, and first name.
+    #
+    # @param [Record] patient The patient for whom we are about to fill in remaining demographic information.
+    # @return A patient with guaranteed complete information necessary for standard formats.
+    def self.finalize_patient(patient)
+      if patient.birthdate.nil?
+        patient.birthdate = Randomizer.randomize_birthdate(patient)
+        patient.birthdate = Time.now.to_i
+      end
+      
+      if patient.gender.nil?
+        # Set gender
+        patient.gender = "F"
+        #rand(2) == 0 ? patient.gender = "M" : patient.gender = "F"
+        patient.first = Randomizer.randomize_first_name(patient.gender)
+      end
+      
+      patient
+    end
+    
+    #
+    #
+    # @param [String] type 
+    # @return 
+    def self.classify_entry(type)
+      # The possible matches per patientAPI function can be found in hqmf-parser's README
+      case type
+      when :allProcedures
+        "procedures"
+      when :proceduresPerformed
+        "procedures"
+      when :procedureResults
+        "lab_results"
+      when :laboratoryTests
+        "vital_signs"
+      when :allMedications
+        "medications"
+      when :activeDiagnoses
+        "conditions"
+      when :inactiveDiagnoses
+        "conditions"
+      when :resolvedDiagnoses
+        "conditions"
+      when :allProblems
+        "conditions"
+      when :allDevices
+        "medical_equipment"
+      else
+        type.to_s
+      end
+    end
+  end
+end