openphar 0.1.0

data/lib/openphar/migrators/phint_migrator.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Openphar
+  module Migrators
+    # Migrates International Pharmacopoeia data from data-international-pharmacopoeia
+    # to Open Pharmacopoeia ontology format
+    #
+    # This class reads existing Ph.Int. JSON-LD files and transforms them to
+    # the OP ontology structure, preserving radiopharmaceutical data and
+    # other Ph.Int.-specific extensions.
+    class PhIntMigrator
+      attr_reader :source_dir, :output_dir, :edition_id
+
+      # Category mapping for organizing monographs
+      CATEGORIES = {
+        "pharmaceutical-substances" => "pharmaceutical-substances",
+        "radiopharmaceuticals" => "radiopharmaceuticals",
+        "crude-drugs" => "crude-drugs",
+        "reagents" => "reagents",
+        "methods" => "methods",
+        "test-solutions" => "reagents/test-solutions",
+        "volumetric-solutions" => "reagents/volumetric-solutions",
+        "buffer-solutions" => "reagents/buffer-solutions",
+        "reference-substances" => "reagents/reference-substances"
+      }.freeze
+
+      # @param source_dir [String] Directory containing Ph.Int. JSON-LD files
+      # @param output_dir [String] Output directory for migrated files
+      # @param edition_id [String] Edition IRI (default: Ph.Int.13)
+      def initialize(source_dir:, output_dir:, edition_id: "https://www.openphar.org/data/edition/phint/phint13")
+        @source_dir = source_dir
+        @output_dir = output_dir
+        @edition_id = edition_id
+        @monographs = []
+        @stats = { total: 0, success: 0, failed: 0, categories: Hash.new(0) }
+      end
+
+      # Run the migration
+      # @return [Hash] Statistics about the migration
+      def run
+        puts "Starting Ph.Int. migration..."
+        puts "  Source: #{source_dir}"
+        puts "  Output: #{output_dir}"
+
+        # Ensure output directories exist
+        ensure_output_directories
+
+        # Process JSON-LD files
+        process_jsonld_files
+
+        # Generate aggregate files
+        generate_aggregate_files
+
+        # Print statistics
+        print_statistics
+
+        @stats
+      end
+
+      private
+
+      def ensure_output_directories
+        CATEGORIES.each_value do |category|
+          dir = File.join(output_dir, "monographs", category)
+          FileUtils.mkdir_p(dir)
+        end
+      end
+
+      def process_jsonld_files
+        # Find all JSON-LD files in source directory
+        jsonld_files = Dir.glob(File.join(source_dir, "**/*.jsonld"))
+        puts "Found #{jsonld_files.count} JSON-LD files"
+
+        jsonld_files.each do |jsonld_file|
+          process_jsonld_file(jsonld_file)
+        end
+      end
+
+      def process_jsonld_file(file_path)
+        puts "Processing #{file_path}..."
+
+        begin
+          content = File.read(file_path, encoding: "UTF-8")
+          data = JSON.parse(content)
+
+          # Handle @graph arrays
+          if data["@graph"]
+            data["@graph"].each do |node|
+              process_node(node)
+            end
+          else
+            process_node(data)
+          end
+        rescue JSON::ParserError => e
+          puts "  ERROR: Invalid JSON - #{e.message}"
+          @stats[:failed] += 1
+        rescue StandardError => e
+          puts "  ERROR: #{e.message}"
+          puts "  #{e.backtrace.first(5).join("\n  ")}"
+          @stats[:failed] += 1
+        end
+      end
+
+      def process_node(node)
+        return unless node.is_a?(Hash)
+        return unless node["@id"] || node["id"]
+
+        @stats[:total] += 1
+
+        # Determine the type and category
+        type = determine_type(node)
+        category = determine_category(node, type)
+        @stats[:categories][category] += 1
+
+        # Transform to OP ontology structure
+        transformed = transform_node(node, type, category)
+
+        # Write individual file
+        slug = generate_slug(node)
+        output_path = File.join(output_dir, "monographs", category, "#{slug}.jsonld")
+        File.write(output_path, JSON.pretty_generate(transformed))
+
+        @monographs << transformed
+        @stats[:success] += 1
+
+        puts "  Created: #{output_path}"
+      end
+
+      def determine_type(node)
+        types = node["@type"] || node["type"] || []
+        types = [types] unless types.is_a?(Array)
+
+        # Map Ph.Int. types to OP types
+        if types.any? { |t| t.to_s.include?("Radiopharmaceutical") }
+          return "RadiopharmaceuticalMonograph"
+        end
+        if types.any? { |t| t.to_s.include?("CrudeDrug") }
+          return "CrudeDrugMonograph"
+        end
+        if types.any? { |t| t.to_s.include?("TestSolution") }
+          return "TestSolution"
+        end
+        if types.any? { |t| t.to_s.include?("VolumetricSolution") }
+          return "VolumetricSolution"
+        end
+        if types.any? { |t| t.to_s.include?("BufferSolution") }
+          return "BufferSolution"
+        end
+        if types.any? { |t| t.to_s.include?("ReferenceSubstance") }
+          return "ReferenceSubstance"
+        end
+
+        "ChemicalDrugMonograph"
+      end
+
+      def determine_category(node, type)
+        case type
+        when "RadiopharmaceuticalMonograph"
+          "radiopharmaceuticals"
+        when "CrudeDrugMonograph"
+          "crude-drugs"
+        when "TestSolution"
+          "reagents/test-solutions"
+        when "VolumetricSolution"
+          "reagents/volumetric-solutions"
+        when "BufferSolution"
+          "reagents/buffer-solutions"
+        when "ReferenceSubstance"
+          "reagents/reference-substances"
+        else
+          # Check for specific characteristics
+          name = node["prefLabel"] || node["rdfs:label"] || node["name"]
+          if name.is_a?(Hash)
+            name = name.values.first
+          end
+
+          if name&.match?(/reagent|solution/i)
+            return "reagents"
+          end
+
+          "pharmaceutical-substances"
+        end
+      end
+
+      def generate_slug(node)
+        # Try to get a name for the slug
+        name = node["prefLabel"] || node["rdfs:label"] || node["name"] || node["skos:prefLabel"]
+        if name.is_a?(Hash)
+          name = name["en"] || name["@value"] || name.values.first
+        end
+
+        return "unknown-#{@stats[:total]}" unless name
+
+        name.to_s.downcase
+            .gsub(/[^a-z0-9\s-]/, "")
+            .gsub(/\s+/, "-")
+            .gsub(/-+/, "-")
+            .strip
+            .sub(/^-/, "")
+            .sub(/-$/, "")
+      end
+
+      def transform_node(node, type, category)
+        slug = generate_slug(node)
+        base_iri = "https://www.openphar.org/data/phint/monographs/#{category}/#{slug}"
+
+        # Get original IRI for reference
+        original_id = node["@id"] || node["id"]
+
+        # Build new JSON-LD structure
+        transformed = {
+          "@context" => "https://www.openphar.org/ontology/context/pharmacopoeia.jsonld",
+          "@id" => base_iri,
+          "@type" => type,
+          "publisher" => "WHO",
+          "belongsToEdition" => @edition_id
+        }
+
+        # Copy over common properties
+        copy_property(transformed, node, "prefLabel", "prefLabel")
+        copy_property(transformed, node, "skos:prefLabel", "prefLabel")
+        copy_property(transformed, node, "rdfs:label", "prefLabel")
+        copy_property(transformed, node, "name", "prefLabel")
+
+        copy_property(transformed, node, "definition", "definition")
+        copy_property(transformed, node, "skos:definition", "definition")
+
+        copy_property(transformed, node, "molecularFormula", "molecularFormula")
+        copy_property(transformed, node, "molecularWeight", "molecularWeight")
+        copy_property(transformed, node, "casNumber", "casNumber")
+
+        # Handle chemical identifiers
+        copy_property(transformed, node, "inchi", "inchi")
+        copy_property(transformed, node, "inchiKey", "inchiKey")
+        copy_property(transformed, node, "smiles", "smiles")
+
+        # Handle test specifications
+        if node["testSpecification"] || node["tests"]
+          specs = node["testSpecification"] || node["tests"]
+          specs = [specs] unless specs.is_a?(Array)
+          transformed["testSpecification"] = specs.map do |spec|
+            transform_test_specification(spec)
+          end
+        end
+
+        # Handle radiopharmaceutical-specific data
+        if type == "RadiopharmaceuticalMonograph"
+          transform_radiopharmaceutical(transformed, node)
+        end
+
+        # Store reference to original IRI
+        if original_id && original_id != base_iri
+          transformed["sameAs"] = original_id
+        end
+
+        transformed.compact
+      end
+
+      def copy_property(target, source, source_key, target_key)
+        value = source[source_key] || source[source_key.to_sym]
+        return unless value
+
+        # Handle language maps
+        if value.is_a?(Hash)
+          if value["@value"]
+            value = value["@value"]
+          elsif value["en"]
+            value = { "en" => value["en"] }
+          elsif value["@language"]
+            lang = value["@language"]
+            value = { lang => value["@value"] }
+          end
+        end
+
+        target[target_key] = value
+      end
+
+      def transform_test_specification(spec)
+        return spec unless spec.is_a?(Hash)
+
+        transformed = {
+          "@type" => spec["@type"] || "TestSpecification"
+        }
+
+        copy_property(transformed, spec, "testName", "testName")
+        copy_property(transformed, spec, "name", "testName")
+        copy_property(transformed, spec, "testType", "testType")
+        copy_property(transformed, spec, "harmonizedMethod", "harmonizedMethod")
+        copy_property(transformed, spec, "testConditions", "testConditions")
+
+        if spec["limit"] || spec["limitValue"]
+          transformed["limit"] = transform_limit(spec["limit"] || spec)
+        end
+
+        transformed.compact
+      end
+
+      def transform_limit(limit_data)
+        return limit_data unless limit_data.is_a?(Hash)
+
+        limit = { "@type" => "Limit" }
+
+        copy_property(limit, limit_data, "limitType", "limitType")
+        copy_property(limit, limit_data, "limitValue", "limitValue")
+        copy_property(limit, limit_data, "lowerLimit", "lowerLimit")
+        copy_property(limit, limit_data, "upperLimit", "upperLimit")
+        copy_property(limit, limit_data, "limitUnit", "limitUnit")
+
+        limit.compact
+      end
+
+      def transform_radiopharmaceutical(transformed, node)
+        # Handle radionuclide data
+        if node["radionuclide"] || node["hasRadionuclide"]
+          rad_data = node["radionuclide"] || node["hasRadionuclide"]
+          rad_data = [rad_data] unless rad_data.is_a?(Array)
+
+          transformed["hasRadionuclide"] = rad_data.map do |rad|
+            if rad.is_a?(Hash)
+              {
+                "@type" => "Radionuclide",
+                "prefLabel" => rad["prefLabel"] || rad["name"],
+                "halfLife" => rad["halfLife"],
+                "emissionType" => rad["emissionType"]
+              }.compact
+            else
+              rad
+            end
+          end
+        end
+
+        # Handle radioactivity-related specifications
+        if node["radiochemicalPurity"]
+          transformed["radiochemicalPurity"] = node["radiochemicalPurity"]
+        end
+
+        if node["radionuclidicPurity"]
+          transformed["radionuclidicPurity"] = node["radionuclidicPurity"]
+        end
+
+        if node["photonFraction"]
+          transformed["photonFraction"] = node["photonFraction"]
+        end
+      end
+
+      def generate_aggregate_files
+        puts "\nGenerating aggregate files..."
+
+        # Generate JSON-LD aggregate
+        jsonld_aggregate = {
+          "@context" => "https://www.openphar.org/ontology/context/pharmacopoeia.jsonld",
+          "@id" => "https://www.openphar.org/data/phint/phint-monographs",
+          "@type" => "Collection",
+          "prefLabel" => { "en" => "International Pharmacopoeia 13 - All Monographs" },
+          "belongsToEdition" => @edition_id,
+          "@graph" => @monographs
+        }
+
+        jsonld_path = File.join(output_dir, "phint-monographs.jsonld")
+        File.write(jsonld_path, JSON.pretty_generate(jsonld_aggregate))
+        puts "  Created: #{jsonld_path}"
+
+        # Generate TTL aggregate
+        ttl_content = generate_ttl_aggregate
+        ttl_path = File.join(output_dir, "phint-monographs.ttl")
+        File.write(ttl_path, ttl_content)
+        puts "  Created: #{ttl_path}"
+      end
+
+      def generate_ttl_aggregate
+        ttl = StringIO.new
+        ttl.puts "@prefix op: <https://www.openphar.org/ontology/core/> ."
+        ttl.puts "@prefix bib: <https://www.openphar.org/ontology/bibliographic/> ."
+        ttl.puts "@prefix phint: <https://www.openphar.org/ontology/publisher/phint/> ."
+        ttl.puts "@prefix skos: <http://www.w3.org/2004/02/skos/core#> ."
+        ttl.puts "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> ."
+        ttl.puts ""
+        ttl.puts "<https://www.openphar.org/data/phint/phint-monographs>"
+        ttl.puts "    a op:Collection ;"
+        ttl.puts "    skos:prefLabel \"International Pharmacopoeia 13 - All Monographs\"@en ;"
+        ttl.puts "    op:belongsToEdition <#{@edition_id}> ;"
+        ttl.puts "    op:monographCount #{@monographs.count} ."
+        ttl.puts ""
+
+        @monographs.each do |monograph|
+          id = monograph["@id"]
+          type = monograph["@type"]
+          label = extract_label(monograph)
+
+          ttl.puts "<#{id}>"
+          ttl.puts "    a op:#{type} ;"
+          ttl.puts "    skos:prefLabel #{label.inspect} ;"
+          ttl.puts "    op:publisher op:WHO ;"
+          ttl.puts "    op:belongsToEdition <#{@edition_id}> ."
+          ttl.puts ""
+        end
+
+        ttl.string
+      end
+
+      def extract_label(monograph)
+        label = monograph["prefLabel"]
+        return "Unknown" unless label
+
+        label.is_a?(Hash) ? (label["en"] || label.values.first) : label
+      end
+
+      def print_statistics
+        puts "\n" + "=" * 50
+        puts "Migration Statistics"
+        puts "=" * 50
+        puts "Total monographs: #{@stats[:total]}"
+        puts "Successfully migrated: #{@stats[:success]}"
+        puts "Failed: #{@stats[:failed]}"
+        puts "\nBy category:"
+        @stats[:categories].each do |category, count|
+          puts "  #{category}: #{count}"
+        end
+        puts "=" * 50
+      end
+    end
+  end
+end

data/lib/openphar/migrators.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Migrators
+    # Migrators for converting source data to Openphar format.
+    #
+    # Handles migration from various pharmacopoeia sources to the
+    # unified Openphar ontology.
+
+    autoload :JpMigrator, 'openphar/migrators/jp_migrator'
+    autoload :PhIntMigrator, 'openphar/migrators/phint_migrator'
+    autoload :Chp, 'openphar/migrators/chp'
+    autoload :ChpMigrator, 'openphar/migrators/chp_migrator'
+  end
+end

data/lib/openphar/models/ahp.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Models
+    # American Herbal Pharmacopoeia (AHP) specific models.
+    #
+    # Contains models unique to the American Herbal Pharmacopoeia:
+    # - Western herbal monographs with comprehensive therapeutic information
+    # - Safety and efficacy profiles
+    # - Detailed analytical methods for botanicals
+    #
+    # @example
+    #   # Access AHP models
+    #   Openphar::Models::AHP::HerbalMonograph
+    #
+    # @see https://www.herbal-ahp.org/
+    module AHP
+      # Placeholder for AHP-specific models
+      # Will include:
+      # - HerbalMonograph (Western herbal medicine)
+      # - TherapeuticProfile
+      # - SafetyProfile
+    end
+  end
+end

data/lib/openphar/models/amino_acid_monograph.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Models
+    # Represents an amino acid monograph
+    #
+    # Amino acids are the building blocks of proteins.
+    class AminoAcidMonograph < ChemicalDrugMonograph
+      attribute :amino_acid_type, :string
+      attribute :essential, :boolean
+
+      json do
+        map 'aminoAcidType', to: :amino_acid_type
+        map 'essential', to: :essential
+      end
+
+      class << self
+        def neo4j_labels
+          %w[Monograph ChemicalDrug AminoAcid]
+        end
+
+        def jsonld_type
+          'AminoAcidMonograph'
+        end
+      end
+    end
+  end
+end

data/lib/openphar/models/api.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Models
+    # Ayurvedic Pharmacopoeia of India (API) specific models.
+    #
+    # Contains models unique to the Ayurvedic Pharmacopoeia of India:
+    # - Dravya (Ayurvedic substances) with Rasa/Guna/Virya/Vipaka/Karma properties
+    # - Traditional Ayurvedic formulations (Asava, Arishta, Bhasma, etc.)
+    # - Classical preparation methods
+    #
+    # @example
+    #   # Access API models
+    #   Openphar::Models::API::DravyaMonograph
+    #   Openphar::Models::API::AyurvedicFormula
+    #
+    # @see https://main.ayush.gov.in/
+    module API
+      # Placeholder for API-specific models
+      # Will include:
+      # - DravyaMonograph (Ayurvedic substances)
+      # - AyurvedicFormula (classical formulations)
+      # - Rasa (taste properties)
+      # - Guna (quality properties)
+      # - Virya (potency)
+      # - Vipaka (post-digestive effect)
+    end
+  end
+end

data/lib/openphar/models/assay_specification.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Models
+    # Represents an assay specification
+    #
+    # Assay specifications define the quantitative determination of
+    # active ingredients or marker compounds.
+    class AssaySpecification < TestSpecification
+      attribute :assay_target, :hash, default: {}
+      attribute :assay_expression, :string
+
+      json do
+        map 'assayTarget', to: :assay_target
+        map 'assayExpression', to: :assay_expression
+      end
+    end
+  end
+end