chemicalml 0.1.0

data/lib/chemicalml/dictionary.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  # Dictionary model layer. Canonical, format-agnostic representation
+  # of CML dictionaries (the dictionary, unit-dictionary, and
+  # unitType-dictionary conventions all share this shape).
+  #
+  # Built-in dictionaries ship as YAML under `data/dictionaries/` and
+  # are loaded into `Chemicalml::Dictionary::Registry` lazily.
+  module Dictionary
+    autoload :Entry,   "chemicalml/dictionary/entry"
+    autoload :Enum,    "chemicalml/dictionary/enum"
+    autoload :Link,    "chemicalml/dictionary/link"
+    autoload :Loader,  "chemicalml/dictionary/loader"
+    autoload :Model,   "chemicalml/dictionary/model"
+    autoload :Registry, "chemicalml/dictionary/registry"
+
+    BUILTIN_DIR = File.expand_path("../../data/dictionaries", __dir__).freeze
+
+    # Convenience: load a built-in dictionary by short name
+    # (e.g. `:compchem`). Returns a `Chemicalml::Dictionary::Model`.
+    def self.load(name)
+      Registry.load_builtin(name)
+    end
+  end
+end

data/lib/chemicalml/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  class Error < StandardError; end
+
+  class ParseError < Error; end
+end

data/lib/chemicalml/model/atom.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A chemical atom. Carries every attribute CML's `<atom>` carries
+    # that's chemistry-relevant: element symbol, formal charge,
+    # isotope, count (multiplicity), hydrogen count, lone pairs,
+    # radical electrons, spin multiplicity.
+    class Atom < Node
+      attr_accessor :id, :element, :formal_charge, :isotope,
+                    :count, :hydrogen_count, :lone_pairs,
+                    :radical_electrons, :spin_multiplicity, :title
+
+      def initialize(element:, id: nil, formal_charge: nil,
+                     isotope: nil, count: nil, hydrogen_count: nil,
+                     lone_pairs: nil, radical_electrons: nil,
+                     spin_multiplicity: nil, title: nil)
+        @element = element
+        @id = id
+        @formal_charge = formal_charge
+        @isotope = isotope
+        @count = count
+        @hydrogen_count = hydrogen_count
+        @lone_pairs = lone_pairs
+        @radical_electrons = radical_electrons
+        @spin_multiplicity = spin_multiplicity
+        @title = title
+      end
+
+      def value_attributes
+        {
+          element: element, id: id, formal_charge: formal_charge,
+          isotope: isotope, count: count, hydrogen_count: hydrogen_count,
+          lone_pairs: lone_pairs, radical_electrons: radical_electrons,
+          spin_multiplicity: spin_multiplicity, title: title
+        }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/bond.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A bond between two atoms. Endpoint references are string IDs
+    # matching `Atom#id`; the kind enum follows CML conventions.
+    class Bond < Node
+      KINDS = %i[single double triple quadruple aromatic wedge hash
+                 dative wavy].freeze
+
+      CML_ORDER = {
+        single: "S", double: "D", triple: "T", quadruple: "Q",
+        aromatic: "A", wedge: "W", hash: "H", dative: "DG", wavy: "V"
+      }.freeze
+
+      attr_accessor :id, :atom_refs, :kind
+
+      def initialize(id: nil, atom_refs:, kind: :single)
+        @id = id
+        @atom_refs = atom_refs
+        @kind = kind
+      end
+
+      def value_attributes
+        { id: id, atom_refs: atom_refs, kind: kind }
+      end
+
+      def cml_order
+        CML_ORDER.fetch(kind, "S")
+      end
+    end
+  end
+end

data/lib/chemicalml/model/cml_array.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A one-dimensional array of values.
+    class Array < Node
+      attr_accessor :id, :title, :dict_ref, :data_type, :units,
+                    :size, :values
+
+      def initialize(values:, data_type: nil, units: nil, size: nil,
+                     id: nil, title: nil, dict_ref: nil)
+        @values = values
+        @data_type = data_type
+        @units = units
+        @size = size
+        @id = id
+        @title = title
+        @dict_ref = dict_ref
+      end
+
+      def value_attributes
+        { values: values, data_type: data_type, units: units,
+          size: size, id: id, title: title, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/cml_module.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A generic grouping container (CML `<module>`). The `dict_ref`
+    # attribute identifies the module's role (e.g.
+    # `compchem:jobList`, `compchem:initialization`).
+    class Module < Node
+      attr_accessor :id, :title, :dict_ref, :convention,
+                    :molecules, :modules, :parameter_lists,
+                    :property_lists, :metadata_lists, :lists
+
+      def initialize(id: nil, title: nil, dict_ref: nil, convention: nil,
+                     molecules: [], modules: [],
+                     parameter_lists: [], property_lists: [],
+                     metadata_lists: [], lists: [])
+        @id = id
+        @title = title
+        @dict_ref = dict_ref
+        @convention = convention
+        @molecules = molecules
+        @modules = modules
+        @parameter_lists = parameter_lists
+        @property_lists = property_lists
+        @metadata_lists = metadata_lists
+        @lists = lists
+      end
+
+      def children
+        molecules + modules + parameter_lists + property_lists + metadata_lists + lists
+      end
+
+      def value_attributes
+        {
+          id: id, title: title, dict_ref: dict_ref, convention: convention,
+          molecules: molecules, modules: modules,
+          parameter_lists: parameter_lists,
+          property_lists: property_lists,
+          metadata_lists: metadata_lists,
+          lists: lists
+        }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/document.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # Top-level container: the canonical document. Parallel to
+    # `AsciiChem::Model::Formula`. Holds an ordered list of
+    # molecules, reactions, and reaction lists.
+    class Document < Node
+      attr_accessor :molecules, :reactions, :reaction_lists
+
+      def initialize(molecules: [], reactions: [], reaction_lists: [])
+        @molecules = molecules
+        @reactions = reactions
+        @reaction_lists = reaction_lists
+      end
+
+      def children
+        molecules + reactions + reaction_lists
+      end
+
+      def value_attributes
+        {
+          molecules: molecules, reactions: reactions,
+          reaction_lists: reaction_lists
+        }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/formula.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # Canonical formula. Three complementary forms: a structured
+    # `atom_array`, a `concise` string (e.g. "C 1 H 4 O 1"), or an
+    # `inline` representation (e.g. LaTeX "H_{3}C-OH").
+    class Formula < Node
+      attr_accessor :id, :concise, :inline, :formal_charge, :count,
+                    :title, :convention, :dict_ref
+
+      def initialize(id: nil, concise: nil, inline: nil,
+                     formal_charge: nil, count: nil, title: nil,
+                     convention: nil, dict_ref: nil)
+        @id = id
+        @concise = concise
+        @inline = inline
+        @formal_charge = formal_charge
+        @count = count
+        @title = title
+        @convention = convention
+        @dict_ref = dict_ref
+      end
+
+      def value_attributes
+        {
+          id: id, concise: concise, inline: inline,
+          formal_charge: formal_charge, count: count, title: title,
+          convention: convention, dict_ref: dict_ref
+        }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/identifier.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # An external identifier: InChI, SMILES, CAS-RN, etc. The
+    # `convention` field tags the identifier kind.
+    class Identifier < Node
+      attr_accessor :value, :convention, :dict_ref
+
+      def initialize(value:, convention: nil, dict_ref: nil)
+        @value = value
+        @convention = convention
+        @dict_ref = dict_ref
+      end
+
+      def value_attributes
+        { value: value, convention: convention, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/label.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A string label with a `dict_ref` pointing to a dictionary entry.
+    class Label < Node
+      attr_accessor :id, :value, :dict_ref, :convention
+
+      def initialize(value:, dict_ref:, id: nil, convention: nil)
+        @value = value
+        @dict_ref = dict_ref
+        @id = id
+        @convention = convention
+      end
+
+      def value_attributes
+        { value: value, dict_ref: dict_ref, id: id, convention: convention }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/matrix.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A two-dimensional rectangular matrix of values.
+    class Matrix < Node
+      attr_accessor :id, :title, :dict_ref, :data_type, :units,
+                    :rows, :columns, :values
+
+      def initialize(values:, rows:, columns:, data_type: nil, units: nil,
+                     id: nil, title: nil, dict_ref: nil)
+        @values = values
+        @rows = rows
+        @columns = columns
+        @data_type = data_type
+        @units = units
+        @id = id
+        @title = title
+        @dict_ref = dict_ref
+      end
+
+      def value_attributes
+        { values: values, rows: rows, columns: columns,
+          data_type: data_type, units: units,
+          id: id, title: title, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/metadata.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A single metadata key/value pair.
+    class Metadata < Node
+      attr_accessor :id, :name, :content, :convention, :title
+
+      def initialize(name:, content:, id: nil, convention: nil, title: nil)
+        @name = name
+        @content = content
+        @id = id
+        @convention = convention
+        @title = title
+      end
+
+      def value_attributes
+        { name: name, content: content, id: id,
+          convention: convention, title: title }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/metadata_list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # Container for `Metadata` instances.
+    class MetadataList < Node
+      attr_accessor :id, :title, :dict_ref, :metadata
+
+      def initialize(metadata: [], id: nil, title: nil, dict_ref: nil)
+        @metadata = metadata
+        @id = id
+        @title = title
+        @dict_ref = dict_ref
+      end
+
+      def children
+        metadata
+      end
+
+      def value_attributes
+        { metadata: metadata, id: id, title: title, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/molecule.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A molecule: ordered atom list + optional bond list + optional
+    # names and identifiers + optional count (multiplicity in a
+    # larger context).
+    class Molecule < Node
+      attr_accessor :id, :atoms, :bonds, :names, :identifiers,
+                    :count, :formal_charge, :title
+
+      def initialize(id: nil, atoms: [], bonds: [], names: [],
+                     identifiers: [], count: nil, formal_charge: nil,
+                     title: nil)
+        @id = id
+        @atoms = atoms
+        @bonds = bonds
+        @names = names
+        @identifiers = identifiers
+        @count = count
+        @formal_charge = formal_charge
+        @title = title
+      end
+
+      def children
+        atoms + bonds + names + identifiers
+      end
+
+      def value_attributes
+        {
+          id: id, atoms: atoms, bonds: bonds, names: names,
+          identifiers: identifiers, count: count,
+          formal_charge: formal_charge, title: title
+        }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/name.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A molecule name. The `convention` field tags the naming scheme
+    # (e.g. `"iupac:systematic"`, `"trivial"`).
+    class Name < Node
+      attr_accessor :content, :convention, :dict_ref
+
+      def initialize(content:, convention: nil, dict_ref: nil)
+        @content = content
+        @convention = convention
+        @dict_ref = dict_ref
+      end
+
+      def value_attributes
+        { content: content, convention: convention, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # Base class for every canonical model node. Mirrors the contract
+    # of `AsciiChem::Model::Node` so visitors written against one
+    # model work against the other without modification.
+    class Node
+      def accept(visitor)
+        visitor.public_send(:"visit_#{self.class.short_name}", self)
+      rescue NoMethodError => e
+        raise unless e.name == :"visit_#{self.class.short_name}"
+
+        raise NotImplementedError,
+              "#{visitor.class} does not implement visit_#{self.class.short_name}"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && value_attributes == other.value_attributes
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, value_attributes].hash
+      end
+
+      def children
+        []
+      end
+
+      def value_attributes
+        {}
+      end
+
+      def self.short_name
+        @short_name ||= begin
+          snake = name.split("::").last
+                      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          snake.downcase
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/model/parameter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # An input parameter — same shape as Property, used for inputs.
+    class Parameter < Node
+      attr_accessor :id, :title, :dict_ref, :convention, :value
+
+      def initialize(value:, dict_ref:, id: nil, title: nil, convention: nil)
+        @value = value
+        @dict_ref = dict_ref
+        @id = id
+        @title = title
+        @convention = convention
+      end
+
+      def children
+        [value].compact
+      end
+
+      def value_attributes
+        { id: id, title: title, dict_ref: dict_ref,
+          convention: convention, value: value }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/parameter_list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # Container for `Parameter` instances.
+    class ParameterList < Node
+      attr_accessor :id, :title, :dict_ref, :parameters
+
+      def initialize(parameters: [], id: nil, title: nil, dict_ref: nil)
+        @parameters = parameters
+        @id = id
+        @title = title
+        @dict_ref = dict_ref
+      end
+
+      def children
+        parameters
+      end
+
+      def value_attributes
+        { parameters: parameters, id: id, title: title, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/product.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    class Product < Node
+      attr_accessor :substance
+
+      def initialize(substance:)
+        @substance = substance
+      end
+
+      def children
+        [substance]
+      end
+
+      def value_attributes
+        { substance: substance }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/product_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    class ProductList < Node
+      attr_accessor :products
+
+      def initialize(products: [])
+        @products = products
+      end
+
+      def children
+        products
+      end
+
+      def value_attributes
+        { products: products }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/property.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # A named property that wraps a value (scalar/array/matrix) and
+    # points to a dictionary entry via `dict_ref`.
+    class Property < Node
+      attr_accessor :id, :title, :dict_ref, :convention, :value
+
+      def initialize(value:, dict_ref:, id: nil, title: nil, convention: nil)
+        @value = value
+        @dict_ref = dict_ref
+        @id = id
+        @title = title
+        @convention = convention
+      end
+
+      def children
+        [value].compact
+      end
+
+      def value_attributes
+        { id: id, title: title, dict_ref: dict_ref,
+          convention: convention, value: value }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/property_list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    # Container for `Property` instances.
+    class PropertyList < Node
+      attr_accessor :id, :title, :dict_ref, :properties
+
+      def initialize(properties: [], id: nil, title: nil, dict_ref: nil)
+        @properties = properties
+        @id = id
+        @title = title
+        @dict_ref = dict_ref
+      end
+
+      def children
+        properties
+      end
+
+      def value_attributes
+        { properties: properties, id: id, title: title, dict_ref: dict_ref }
+      end
+    end
+  end
+end

data/lib/chemicalml/model/reactant.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+      class Reactant < Node
+        attr_accessor :substance
+
+        def initialize(substance:)
+          @substance = substance
+        end
+
+        def children
+          [substance]
+        end
+
+        def value_attributes
+          { substance: substance }
+        end
+      end
+  end
+end

data/lib/chemicalml/model/reactant_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Model
+    class ReactantList < Node
+      attr_accessor :reactants
+
+      def initialize(reactants: [])
+        @reactants = reactants
+      end
+
+      def children
+        reactants
+      end
+
+      def value_attributes
+        { reactants: reactants }
+      end
+    end
+  end
+end