chemicalml 0.2.0 → 0.3.0

data/lib/chemicalml/model/cml_module.rb

@@ -1,45 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

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

data/lib/chemicalml/model/name.rb

@@ -1,21 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

data/lib/chemicalml/model/reaction.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Chemicalml
-  module Model
-    # A chemical reaction. Reactants, products, arrow kind, optional
-    # conditions (above / below the arrow).
-    class Reaction < Node
-      ARROWS = %i[forward reverse equilibrium resonance].freeze
-
-      attr_accessor :id, :reactant_list, :product_list, :arrow,
-                    :conditions_above, :conditions_below, :title, :type
-
-      def initialize(id: nil, reactant_list:, product_list:,
-                     arrow: :forward, conditions_above: nil,
-                     conditions_below: nil, title: nil, type: nil)
-        @id = id
-        @reactant_list = reactant_list
-        @product_list = product_list
-        @arrow = arrow
-        @conditions_above = conditions_above
-        @conditions_below = conditions_below
-        @title = title
-        @type = type
-      end
-
-      def children
-        [reactant_list, product_list]
-      end
-
-      def value_attributes
-        {
-          id: id, reactant_list: reactant_list,
-          product_list: product_list, arrow: arrow,
-          conditions_above: conditions_above,
-          conditions_below: conditions_below,
-          title: title, type: type
-        }
-      end
-    end
-  end
-end

data/lib/chemicalml/model/reaction_list.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Chemicalml
-  module Model
-    # A reaction cascade: ordered list of `Reaction` instances where
-    # each step's products are the next step's reactants.
-    class ReactionList < Node
-      attr_accessor :reactions
-
-      def initialize(reactions: [])
-        @reactions = reactions
-      end
-
-      def children
-        reactions
-      end
-
-      def value_attributes
-        { reactions: reactions }
-      end
-    end
-  end
-end

data/lib/chemicalml/model/scalar.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Chemicalml
-  module Model
-    # A primitive scalar value with a data type and units.
-    class Scalar < Node
-      attr_accessor :id, :title, :dict_ref, :data_type, :units, :value
-
-      def initialize(value:, data_type: nil, units: nil, id: nil,
-                     title: nil, dict_ref: nil)
-        @value = value
-        @data_type = data_type
-        @units = units
-        @id = id
-        @title = title
-        @dict_ref = dict_ref
-      end
-
-      def value_attributes
-        { value: value, data_type: data_type, units: units,
-          id: id, title: title, dict_ref: dict_ref }
-      end
-    end
-  end
-end

data/lib/chemicalml/model/substance.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Chemicalml
-  module Model
-    # A reaction participant. Wraps a `Molecule` with a `role`
-    # (e.g. `:reactant`, `:product`, `:catalyst`, `:solvent`).
-    class Substance < Node
-      attr_accessor :molecule, :role, :title
-
-      def initialize(molecule:, role: nil, title: nil)
-        @molecule = molecule
-        @role = role
-        @title = title
-      end
-
-      def children
-        [molecule]
-      end
-
-      def value_attributes
-        { molecule: molecule, role: role, title: title }
-      end
-    end
-  end
-end