chem_scanner 0.1.3

data/lib/chem_scanner/interpreter/element/molecule_group.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    # MoleculeGroup - molecules represented as text
+    class MoleculeGroup
+      attr_accessor :title
+      attr_reader :polygon, :molecules, :molecule_ids
+
+      def initialize(title = nil)
+        @title = title
+        @molecules = []
+        @molecule_ids = []
+      end
+
+      def add_fragment(fragment)
+        mol = Molecule.new(fragment)
+        mol.process
+        mol.abbreviation = title.value
+        molecules.push(mol)
+        @molecule_ids.push(fragment.id)
+      end
+
+      def inspect
+        (
+          "#<MoleculeGroup: id=#{@title.id}, " +
+            "text: #{@title}, " +
+            "molecule_ids: #{@molecule_ids}, " +
+            "molecules: #{@molecules} >"
+        )
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/element/reaction.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    # Reaction
+    class Reaction
+      attr_accessor :reactant_ids, :reagent_ids, :product_ids,
+                    :text_ids, :arrow_id, :arrow,
+                    :reactants, :products, :reagents,
+                    :reagent_smiles, :reagent_abbs,
+                    :description, :temperature, :yield, :time,
+                    :steps, :details, :clone_from
+
+      def initialize
+        @arrow = nil
+
+        @reactant_ids = []
+        @reagent_ids = []
+        @product_ids = []
+        @text_ids = []
+
+        @reactants = []
+        @reagents = []
+        @products = []
+        @reagent_smiles = []
+        @reagent_abbs = []
+
+        @description = ""
+        @temperature = ""
+        @yield = ""
+        @time = ""
+        @details = OpenStruct.new
+
+        @steps = []
+      end
+
+      def reaction_smiles
+        reactant_smiles = @reactants.map(&:cano_smiles).join(".")
+        product_smiles = @products.map(&:cano_smiles).join(".")
+
+        reagent_smiles = @reagents.map(&:cano_smiles).compact
+        reagent_smiles = reagent_smiles.concat(@reagent_smiles).join(".")
+
+        "#{reactant_smiles}>#{reagent_smiles}>#{product_smiles}"
+      end
+
+      def reactant_molfiles
+        @reactants.map { |r| r[:mdl] }
+      end
+
+      def reagent_molfiles
+        @reagents.map { |r| r[:mdl] }
+      end
+
+      def product_molfiles
+        @products.map { |r| r[:mdl] }
+      end
+
+      def debug_print
+        "reaction #{@arrow_id}: "\
+        "#{reactant_ids} > #{reagent_ids} > #{product_ids}"
+      end
+
+      def debug_print_smiles
+        "reaction #{@arrow_id}: "\
+        "#{reactant_ids} - #{reagent_ids} - #{product_ids}: #{reaction_smiles}"
+      end
+
+      def molecule_ids
+        @reactant_ids + @product_ids
+      end
+
+      def all_ids
+        @reagent_ids + molecule_ids
+      end
+
+      def delete_id(id)
+        [@reactant_ids, @reagent_ids, @product_ids].each do |group|
+          group.delete(id) if group.include?(id)
+        end
+      end
+
+      def replace_id(old_id, new_id)
+        [@reactant_ids, @reagent_ids, @product_ids].each do |group|
+          next unless group.include?(old_id)
+
+          group.delete(old_id)
+          group.push(new_id)
+        end
+      end
+
+      def replace_molecule(old_id, new_mol)
+        oid = old_id
+
+        [@reactants, @reagents, @products].each do |group|
+          idx = group.index { |m| [m.id, m.clone_from].include?(old_id) }
+          next if idx.nil?
+
+          m = group[idx]
+          oid = m.clone_from unless m.clone_from.nil?
+          group[idx] = new_mol
+        end
+
+        replace_id(oid, new_mol.id)
+      end
+
+      def delete_molecule_by_id(id)
+        [@reactants, @reagents, @products].each do |group|
+          group.delete_if { |mol| mol.id == id }
+        end
+      end
+
+      def status
+        return "Failed" if @arrow.cross
+        return "Planned" if @arrow.line_type == 1
+
+        return "Failed" unless @products.detect(&:check_red).nil?
+
+        "Succesful"
+      end
+
+      def clone
+        cloned = self.class.new
+        unless @arrow.nil?
+          cloned.arrow_id = @arrow.get_tempid
+          cloned.arrow = @arrow.clone
+        end
+
+        %w[reactant reagent product].each do |group|
+          cloned_groups = cloned.send("#{group}s")
+          groups = instance_variable_get("@#{group}s")
+
+          groups.each { |m| cloned_groups.push(m.clone) }
+          cloned.send("#{group}_ids=", cloned_groups.map(&:id))
+        end
+
+        cloned.reagent_smiles = @reagent_smiles.dup
+
+        cloned.description = @description.dup
+        cloned.temperature = @temperature.dup
+        cloned.yield = @yield.dup
+        cloned.time = @time.dup
+        cloned.details = @details.dup
+
+        cloned.clone_from = @clone_from.nil? ? arrow_id : @clone_from
+
+        cloned
+      end
+
+      def to_hash
+        {
+          id: arrow_id,
+          reactants: @reactants.sort_by(&:cano_smiles).map(&:to_hash),
+          reagents: @reagents.sort_by(&:cano_smiles).map(&:to_hash),
+          products: @products.sort_by(&:cano_smiles).map(&:to_hash),
+          steps: @steps.map(&:to_hash),
+          reagent_smiles: reagent_smiles.sort,
+          description: @description,
+          temperature: @temperature,
+          yield: @yield,
+          time: @time,
+          details: @details.to_h,
+        }
+      end
+
+      def inspect
+        (
+          "#<Reaction: id=#{@arrow.id}, " +
+          "reactant_ids=#{@reactant_ids}, " +
+          "reagent_ids=#{@reagent_ids}, " +
+          "product_ids=#{@product_ids}, " +
+          "text_ids=#{@text_ids}, " +
+          "reactants=#{@reactants}, " +
+          "reagents=#{@reagents}, " +
+          "products=#{@products}, " +
+          "reagent_smiles=#{@reagent_smiles}, " +
+          "description=#{@description}, " +
+          "temperature=#{@temperature}, " +
+          "yield=#{@yield}, " +
+          "time=#{@time}, " +
+          "details=#{@details} >"
+        )
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/element/reaction_step.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    # Reaction Step
+    class ReactionStep
+      attr_accessor :description, :time, :temperature, :reagents, :number
+
+      def initialize
+        @number = 0
+        @description = ""
+        @time = ""
+        @temperature = ""
+
+        @reagents = []
+      end
+
+      def inspect
+        (
+          "#<ReactionStep: description=#{@description}, " +
+          "number=#{@number}, " +
+          "time=#{@time}, " +
+          "temperature=#{@temperature}, " +
+          "reagents=#{@reagents}"
+        )
+      end
+
+      def to_hash
+        {
+          number: @number,
+          description: @description,
+          time: @time,
+          temperature: @temperature,
+          reagents: @reagents,
+        }
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/formula_to_mol.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    OPEN_MARK = '[\(\[\{]'.freeze
+    CLOSE_MARK = '[\)\]\}]'.freeze
+
+    # NOTE: WIP file
+    def mol_from_inorganic_formula(text)
+      return nil unless text.class == String
+
+      string = text.dup
+      iter = string =~ /#{OPEN_MARK}/
+      return parse_formula(text) if iter.nil?
+
+      reverse_string = string.reverse
+      reverse_iter = reverse_string =~ /#{CLOSE_MARK}/
+
+      math_data = text.match(formula_regex)
+    end
+
+    def parse_formula(formula, out_valence = 0)
+      # NOTE: sort alphabetically then by length,
+      # so that C will not be catched first in Ca
+      el_names = ELEMENTS.map { |x| x["name"] }
+      els = el_names.sort_by { |a| [a[0], -a.size] }.join("|")
+      num = "[1-9]"
+      charge = "[-+]"
+      return nil unless formula.split(/#{els}|#{num}|#{charge}/).empty?
+
+      el_arr = formula.scan(/(#{els})(#{num}{0,2})/).map do |el, elnum|
+        el_info = ELEMENTS.detect { |e| e["name"] == el }
+        return nil if el_info.nil? || el_info["valences"][2].first.zero?
+
+        {
+          name: el,
+          num: elnum.empty? ? 1 : elnum.to_i,
+          valences: el_info["valences"][2],
+        }
+      end
+      return nil if el_arr.size == 1
+
+      # el_arr.sort_by! { |el| el[:valences].max }
+      fel = el_arr.first
+      others = el_arr[1..-1]
+
+      valence_combination = []
+      idx_map = others.map { |el| el[:valences].count - 1 }
+
+      fel[:valences].each do |fvalen|
+        idx_iter = Array.new(idx_map.size, 0)
+        iter = idx_iter.size - 1
+        stop = false
+
+        until stop do
+          vasum = idx_iter.reduce(0) do |sum, idx|
+            el_valence = others[idx][:valences]
+            cur_val = idx_iter[idx]
+            sum += el_valence[cur_val]
+          end
+
+          valence_combination.push(idx_iter) if (vasum + fvalen) == out_valence
+
+          if idx_iter[iter] == idx_map[iter]
+            stope = true if iter.zero?
+            iter -= 1
+          else
+            idx_iter[iter] += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/post_process/assemble.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  # Interpret the parsed/extracted geometry block
+  module Interpreter
+    class Scheme
+      def assemble_reaction
+        @reactions.each do |r|
+          %w[reactant reagent product].each do |group|
+            group_ids = r.send("#{group}_ids")
+            groups = r.send("#{group}s")
+
+            group_ids.each do |id|
+              if @text_map.key?(id)
+                r.text_ids.push(id)
+                next
+              end
+
+              if @mol_map.key?(id)
+                groups.push(@mol_map[id])
+                next
+              end
+
+              @mol_group_map.select do |_, mgroup|
+                mgroup.molecule_ids.include?(id)
+              end.each do |_, mgroup|
+                groups.push(mgroup.molecules.first)
+              end
+            end
+          end
+
+          r.arrow = @arrow_map[r.arrow_id]
+          r.text_ids.concat(r.arrow.text_arr).uniq!
+        end
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/post_process/label_by_molecule.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module PostProcess
+      def replace_label_by_molecule
+        @reactions.each do |r|
+          @arrow_map[r.arrow_id].text_arr.each do |tid|
+            text = @text_map[tid]
+
+            bolds = text.bold_text.strip.split(ABB_DELIM).reject(&:empty?)
+            bolds.each do |bold|
+              mol = @mol_map.detect { |_, m| m.label == bold }
+              next if mol.nil?
+
+              mid = mol[0]
+              r.reagent_ids.push(mid) unless r.reagent_ids.include?(mid)
+            end
+
+            non_bolds = text.non_bold_text.strip.split(ABB_DELIM)
+            non_bolds.reject(&:empty?).each do |plain|
+              next if plain.length < 3 || !(plain =~ /eq(uiv)?\.?/).nil?
+
+              mol = @mol_map.detect { |_, m| m.text.strip == plain.strip }
+              next if mol.nil?
+
+              mid = mol[0]
+              r.reagent_ids.push(mid) unless r.reagent_ids.include?(mid)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/post_process/reaction_info.rb

@@ -0,0 +1,225 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module ChemScanner
+  # Interpreter of extracted/scanned information
+  module Interpreter
+    using Extension
+
+    JOIN_WORDS = %w[and with plus].freeze
+
+    START_REGEX = '(?<=\s|,|;|\n|\r|\[|\(|\.|\A|^)+'
+    ENDING_REGEX = '(?=\s|,|;|\n|\r|\]|\)|\.|\z|$)+'
+
+    DEGREE_REGEX = '((°\s*[CF])|(℃|℉))'
+    RANGE_REGEX = "(-|−|–|—|~|to|till|until)"
+
+    module PostProcess
+      def process_reaction_info(reaction)
+        descs = []
+        reaction.text_ids.each do |tid|
+          text_obj = @text_map[tid]
+          text = text_obj.value
+          descs.push(text)
+
+          mgroup = @mol_group_map[tid]
+          if mgroup.nil?
+            abb_mol = name_to_struct(text)
+            reaction.reagent_smiles.concat(abb_mol.values)
+            reaction.reagent_abbs.concat(abb_mol.keys)
+          else
+            mtext = mgroup.title.value
+
+            if mtext == text
+              merge_chemdraw_with_predefined(mgroup, reaction)
+            else
+              descs.push(mtext)
+              reaction.reagents.concat(mgroup.molecules)
+
+              abb_mol = name_to_struct(mtext)
+              reaction.reagent_smiles.concat(abb_mol.values)
+            end
+          end
+        end
+
+        temperature, ryield, time = extract_reaction_info(descs)
+        pyield = extract_product_yield(reaction)
+
+        reaction.temperature = temperature
+        reaction.yield = pyield.empty? ? ryield : pyield
+        reaction.time = time
+        reaction.description = descs.reject { |e| e.to_s.empty? }.join("\n")
+      end
+
+      def split_text(text)
+        text.split(ABB_DELIM).select { |t| t.length > 1 }
+      end
+
+      def name_to_struct(text)
+        smis = {}
+        remain = []
+        text_arr = split_text(text)
+
+        text_arr.each do |t|
+          smi = ChemScanner.get_abbreviation(t)
+
+          if smi.empty?
+            remain.push(t)
+          else
+            smis[t] = smi
+          end
+        end
+
+        unless remain.empty?
+          tmp = remain.join(" ")
+
+          ChemScanner.all_abbreviations.keys.select do |key|
+            key.include?(" ")
+          end.each do |abb|
+            next unless tmp.include?(abb)
+
+            tmp.slice!(abb)
+            smis[abb] = ChemScanner.get_abbreviation(abb)
+          end
+        end
+
+        smis
+      end
+
+      def merge_chemdraw_with_predefined(mgroup, reaction)
+        mtext = mgroup.title.value
+        abb_hash = name_to_struct(mtext)
+
+        text_arr = split_text(mtext)
+        text_arr.each_with_index do |text, idx|
+          abb_smi = abb_hash[text]
+
+          if abb_smi.nil?
+            mol = mgroup.molecules[idx]
+            reaction.reagents.push(mol) unless mol.nil?
+          else
+            reaction.reagent_smiles.push(abb_smi)
+          end
+        end
+      end
+
+      def extract_reaction_info(descs)
+        ryield = []
+        temperatures = []
+        times = []
+
+        descs.each do |desc|
+          dyield = extract_yield_info(desc)
+          ryield.push(dyield) unless dyield.empty?
+
+          temp = extract_temperature(desc)
+          temperatures.push(temp) unless temp.empty?
+
+          time = extract_time_info(desc)
+          times.push(time) unless time.empty?
+        end
+
+        [
+          temperatures.join(";"),
+          ryield.join(";"),
+          times.join(";"),
+        ]
+      end
+
+      def extract_product_yield(reaction)
+        pyields = []
+
+        reaction.products.each do |mol|
+          next if mol.text.strip.empty?
+
+          pyield = extract_yield_info(mol.text.strip)
+          pyields.push(pyield)
+        end
+
+        pyields.join(";")
+      end
+
+      def range_number_regex(unit_regex, can_negative)
+        sign = can_negative ? "(-|−|–|—)?\\s*" : ""
+        real_number = "(\\d+|\\d+\.\\d+)"
+
+        "#{sign}(#{real_number}\\s*#{unit_regex}?\\s*" \
+        "#{RANGE_REGEX})?#{real_number}\\s*#{unit_regex}"
+      end
+
+      def time_duration_range_regex
+        day = "days?|dy|d"
+        hour = "hours?|hrs?|h"
+        minute = "minutes?|mins?|m"
+        second = "seconds?|secs?|s"
+        real_number = '(\d+|\d+\.\d+)'
+
+        time_unit = "(#{day}|#{hour}|#{minute}|#{second})"
+        time_regex = "#{real_number}\\s*#{time_unit}"
+        join_words = JOIN_WORDS.join("|")
+        linker_regex = "(#{RANGE_REGEX}|(#{join_words}))"
+
+        %r{
+          #{START_REGEX}
+          (#{time_regex}?\s*(#{linker_regex}\s*)?(#{real_number}\s*#{time_unit}))
+          #{ENDING_REGEX}
+        }x
+      end
+
+      def extract_yield_info(text)
+        yield_regex_str = range_number_regex("%", false)
+        yield_regex = %r{
+          #{START_REGEX}
+          #{yield_regex_str}(?!\s*ee)
+          #{ENDING_REGEX}
+        }x
+
+        text_regex(text, yield_regex)
+      end
+
+      def extract_time_info(text)
+        time = []
+        text.scan(time_duration_range_regex) { |m| time << m[0] }
+
+        ovn_regex = "overnight|ovn|o/n"
+        ovn_regex = %r{
+          #{START_REGEX}
+          (#{ovn_regex}?)
+          #{ENDING_REGEX}
+        }xi
+        ovn = text_regex(text, ovn_regex)
+        time.push("12h ~ 20h") unless ovn.empty?
+
+        time.join(";")
+      end
+
+      def extract_temperature(text)
+        temp_regex_str = range_number_regex(DEGREE_REGEX, true)
+        temperature_regex = %r{
+          #{START_REGEX}
+          #{temp_regex_str}
+          #{ENDING_REGEX}
+        }x
+        temp = text_regex(text, temperature_regex)
+
+        rt_regex = %r{
+          #{START_REGEX}
+          r\.?t\.?
+          #{ENDING_REGEX}
+        }xi
+        m = text.match(rt_regex)
+        return temp if m.nil? || m[0].empty?
+
+        rt = "20°C ~ 25°C"
+        temp.empty? ? rt : "#{temp}; #{rt}"
+      end
+
+      def text_regex(text, regex)
+        m = text.match(regex)
+        return "" if m.nil?
+
+        m[0].strip
+      end
+    end
+  end
+end