tomoto 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b40c9adf2f0162eb6174b17395ea37b9294e14b22609e9f51951e9904125ff9
-  data.tar.gz: be3f68438f60a7e4fc11033921636f8d03bf411bd3d3eb6aa3b4fb448faac41a
+  metadata.gz: dd4c36ff621f73c38bb066694a932f0a682c18591ddf05a9a0764bea0b6e4430
+  data.tar.gz: 551e56c4bc17fb5a3a0aeac0db055960fcc5e45bf097bf88c7cbf9046f958e7d
 SHA512:
-  metadata.gz: a74747ae372d030c42562d4e2b99ab167ccc28533468ed08819f4bd34d42b340349870712c12e565388eb7833f993349432e77baee8618c34c265676ca181072
-  data.tar.gz: da9e833bb98726278108a68a7dd6bed0e54b3979c25d49d8db01aa613e6205a6a3512881688209baf2589c4dc5514ed2663fb251a5e273c42b678bb1daa06d74
+  metadata.gz: 565a91d0bb6d48142f38dc3d9e798ddb99bf41fda32762295362075fba972eea6b56b6bde126eab74677eba5fd525581b68c5efa73361a46fcb0b2796ab63684
+  data.tar.gz: 415193e4eb6adbe5dce05328aadf9acb91f4acc50951484183a956455d7336f93961fe145465b1eeffaae78dad37ee1452defe832514c72b3c032860ed433cc8

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.2 (2020-10-10)
+
+- Added `summary` method
+- Added `parallel` option to `train` method
+
 ## 0.1.1 (2020-10-10)
 
 - Added many more models

data/README.md

@@ -23,7 +23,13 @@ model = Tomoto::LDA.new(k: 3)
 model.add_doc("text from document one")
 model.add_doc("text from document two")
 model.add_doc("text from document three")
-model.train(100)
+model.train(100) # iterations
+```
+
+Get the summary
+
+```ruby
+model.summary
 ```
 
 Get topic words
@@ -89,6 +95,11 @@ This library follows the [tomotopy API](https://bab2min.github.io/tomotopy/v0.9.
 
 If a method or option you need isn’t supported, feel free to open an issue.
 
+## Examples
+
+- [LDA](examples/lda_basic.rb)
+- [HDP](examples/hdp.rb)
+
 ## Tokenization
 
 Documents are tokenized by whitespace by default, or you can perform your own tokenization.
@@ -99,12 +110,22 @@ model.add_doc(["tokens", "from", "document", "one"])
 
 ## Performance
 
-tomoto uses AVX2, AVX, or SSE2 instructions to increase performance on machines that support it. Check what it’s using with:
+tomoto uses AVX2, AVX, or SSE2 instructions to increase performance on machines that support it. Check which instruction set architecture it’s using with:
 
 ```ruby
 Tomoto.isa
 ```
 
+## Parallelism
+
+Choose a [parallelism algorithm](https://bab2min.github.io/tomotopy/v0.9.0/en/#parallel-sampling-algorithms) with:
+
+```ruby
+model.train(parallel: :partition)
+```
+
+Supported values are `:default`, `:none`, `:copy_merge`, and `:partition`.
+
 ## History
 
 View the [changelog](https://github.com/ankane/tomoto/blob/master/CHANGELOG.md)

data/ext/tomoto/ext.cpp

@@ -31,7 +31,7 @@ using Rice::define_class_under;
 using Rice::define_module;
 
 template<>
-Object to_ruby<std::vector<float>>(std::vector<float> const & x)
+Object to_ruby<std::vector<tomoto::Float>>(std::vector<tomoto::Float> const & x)
 {
   Array res;
   for (auto const& v : x) {
@@ -73,13 +73,13 @@ std::vector<std::string> from_ruby<std::vector<std::string>>(Object x)
 }
 
 template<>
-std::vector<float> from_ruby<std::vector<float>>(Object x)
+std::vector<tomoto::Float> from_ruby<std::vector<tomoto::Float>>(Object x)
 {
   Array a = Array(x);
-  std::vector<float> res;
+  std::vector<tomoto::Float> res;
   res.reserve(a.size());
   for (auto const& v : a) {
-    res.push_back(from_ruby<float>(v));
+    res.push_back(from_ruby<tomoto::Float>(v));
   }
   return res;
 }
@@ -117,7 +117,7 @@ void Init_ext()
   Class rb_cLDA = define_class_under<tomoto::ILDAModel>(rb_mTomoto, "LDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, float alpha, float eta, int seed) {
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -131,7 +131,11 @@ void Init_ext()
     .define_method(
       "alpha",
       *[](tomoto::ILDAModel& self) {
-        return self.getAlpha();
+        Array res;
+        for (size_t i = 0; i < self.getK(); i++) {
+          res.push(self.getAlpha(i));
+        }
+        return res;
       })
     .define_method(
       "burn_in",
@@ -246,8 +250,7 @@ void Init_ext()
       })
     .define_method(
       "_train",
-      *[](tomoto::ILDAModel& self, size_t iteration, size_t workers) {
-        size_t ps = 0;
+      *[](tomoto::ILDAModel& self, size_t iteration, size_t workers, size_t ps) {
         self.train(iteration, workers, (tomoto::ParallelScheme)ps);
       })
     .define_method(
@@ -321,7 +324,7 @@ void Init_ext()
   Class rb_cCT = define_class_under<tomoto::ICTModel, tomoto::ILDAModel>(rb_mTomoto, "CT")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, float alpha, float eta, int seed) {
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -368,7 +371,7 @@ void Init_ext()
   Class rb_cDMR = define_class_under<tomoto::IDMRModel, tomoto::ILDAModel>(rb_mTomoto, "DMR")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, float alpha, float sigma, float eta, float alpha_epsilon, int seed) {
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float eta, tomoto::Float alpha_epsilon, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -386,7 +389,7 @@ void Init_ext()
       })
     .define_method(
       "alpha_epsilon=",
-      *[](tomoto::IDMRModel& self, float value) {
+      *[](tomoto::IDMRModel& self, tomoto::Float value) {
         self.setAlphaEps(value);
         return value;
       })
@@ -420,7 +423,7 @@ void Init_ext()
   Class rb_cDT = define_class_under<tomoto::IDTModel, tomoto::ILDAModel>(rb_mTomoto, "DT")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, size_t t, float alphaVar, float etaVar, float phiVar, float shapeA, float shapeB, float shapeC) {
+      *[](size_t tw, size_t k, size_t t, tomoto::Float alphaVar, tomoto::Float etaVar, tomoto::Float phiVar, tomoto::Float shapeA, tomoto::Float shapeB, tomoto::Float shapeC) {
         // Rice only supports 10 arguments
         int seed = -1;
         if (seed < 0) {
@@ -440,7 +443,7 @@ void Init_ext()
       })
     .define_method(
       "lr_a=",
-      *[](tomoto::IDTModel& self, float value) {
+      *[](tomoto::IDTModel& self, tomoto::Float value) {
         self.setShapeA(value);
         return value;
       })
@@ -451,7 +454,7 @@ void Init_ext()
       })
     .define_method(
       "lr_b=",
-      *[](tomoto::IDTModel& self, float value) {
+      *[](tomoto::IDTModel& self, tomoto::Float value) {
         self.setShapeB(value);
         return value;
       })
@@ -462,7 +465,7 @@ void Init_ext()
       })
     .define_method(
       "lr_c=",
-      *[](tomoto::IDTModel& self, float value) {
+      *[](tomoto::IDTModel& self, tomoto::Float value) {
         self.setShapeC(value);
         return value;
       })
@@ -480,7 +483,7 @@ void Init_ext()
   Class rb_cGDMR = define_class_under<tomoto::IGDMRModel, tomoto::IDMRModel>(rb_mTomoto, "GDMR")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, std::vector<uint64_t> degrees, float alpha, float sigma, float sigma0, float eta, float alpha_epsilon, int seed) {
+      *[](size_t tw, size_t k, std::vector<uint64_t> degrees, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float sigma0, tomoto::Float eta, tomoto::Float alpha_epsilon, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -500,12 +503,17 @@ void Init_ext()
   Class rb_cHDP = define_class_under<tomoto::IHDPModel, tomoto::ILDAModel>(rb_mTomoto, "HDP")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, float alpha, float eta, float gamma, int seed) {
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
         return tomoto::IHDPModel::create((tomoto::TermWeight)tw, k, alpha, eta, gamma, seed);
       })
+    .define_method(
+      "alpha",
+      *[](tomoto::IHDPModel& self) {
+        return self.getAlpha();
+      })
     .define_method(
       "gamma",
       *[](tomoto::IHDPModel& self) {
@@ -530,12 +538,21 @@ void Init_ext()
   Class rb_cHLDA = define_class_under<tomoto::IHLDAModel, tomoto::ILDAModel>(rb_mTomoto, "HLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t levelDepth, float alpha, float eta, float gamma, int seed) {
+      *[](size_t tw, size_t levelDepth, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
         return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, levelDepth, alpha, eta, gamma, seed);
       })
+    .define_method(
+      "alpha",
+      *[](tomoto::IHLDAModel& self) {
+        Array res;
+        for (size_t i = 0; i < self.getLevelDepth(); i++) {
+          res.push(self.getAlpha(i));
+        }
+        return res;
+      })
     .define_method(
       "_children_topics",
       *[](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
@@ -580,7 +597,7 @@ void Init_ext()
   Class rb_cPA = define_class_under<tomoto::IPAModel, tomoto::ILDAModel>(rb_mTomoto, "PA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k1, size_t k2, float alpha, float eta, int seed) {
+      *[](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -600,17 +617,27 @@ void Init_ext()
   Class rb_cHPA = define_class_under<tomoto::IHPAModel, tomoto::IPAModel>(rb_mTomoto, "HPA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k1, size_t k2, float alpha, float eta, int seed) {
+      *[](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
         return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, k1, k2, alpha, eta, seed);
+      })
+    .define_method(
+      "alpha",
+      *[](tomoto::IHPAModel& self) {
+        Array res;
+        // use <= to return k+1 elements
+        for (size_t i = 0; i <= self.getK(); i++) {
+          res.push(self.getAlpha(i));
+        }
+        return res;
       });
 
   Class rb_cMGLDA = define_class_under<tomoto::IMGLDAModel, tomoto::ILDAModel>(rb_mTomoto, "MGLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k_g, size_t k_l, size_t t, float alpha_g, float alpha_l, float alpha_mg, float alpha_ml, float eta_g) {
+      *[](size_t tw, size_t k_g, size_t k_l, size_t t, tomoto::Float alpha_g, tomoto::Float alpha_l, tomoto::Float alpha_mg, tomoto::Float alpha_ml, tomoto::Float eta_g) {
         return tomoto::IMGLDAModel::create((tomoto::TermWeight)tw, k_g, k_l, t, alpha_g, alpha_l, alpha_mg, alpha_ml, eta_g);
       })
     .define_method(
@@ -672,7 +699,7 @@ void Init_ext()
   Class rb_cLLDA = define_class_under<tomoto::ILLDAModel, tomoto::ILDAModel>(rb_mTomoto, "LLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, float alpha, float eta, int seed) {
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -692,7 +719,7 @@ void Init_ext()
   Class rb_cPLDA = define_class_under<tomoto::IPLDAModel, tomoto::ILLDAModel>(rb_mTomoto, "PLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t latent_topics, float alpha, float eta, int seed) {
+      *[](size_t tw, size_t latent_topics, tomoto::Float alpha, tomoto::Float eta, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -712,7 +739,7 @@ void Init_ext()
   Class rb_cSLDA = define_class_under<tomoto::ISLDAModel, tomoto::ILDAModel>(rb_mTomoto, "SLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, Array rb_vars, float alpha, float eta, std::vector<float> mu, std::vector<float> nu_sq, std::vector<float> glm_param, int seed) {
+      *[](size_t tw, size_t k, Array rb_vars, tomoto::Float alpha, tomoto::Float eta, std::vector<tomoto::Float> mu, std::vector<tomoto::Float> nu_sq, std::vector<tomoto::Float> glm_param, int seed) {
         if (seed < 0) {
           seed = std::random_device{}();
         }
@@ -725,7 +752,7 @@ void Init_ext()
       })
     .define_method(
       "_add_doc",
-      *[](tomoto::ISLDAModel& self, std::vector<std::string> words, std::vector<float> y) {
+      *[](tomoto::ISLDAModel& self, std::vector<std::string> words, std::vector<tomoto::Float> y) {
         self.addDoc(words, y);
       })
     .define_method(

data/lib/tomoto.rb

@@ -18,5 +18,6 @@ require "tomoto/slda"
 require "tomoto/version"
 
 module Tomoto
+  PARALLEL_SCHEME = [:default, :none, :copy_merge, :partition]
   TERM_WEIGHT = [:one, :idf, :pmi]
 end

data/lib/tomoto/ct.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def correlations(topic_id = nil)

data/lib/tomoto/dmr.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, metadata: "")
@@ -19,5 +19,9 @@ module Tomoto
         k.times.map { |i| _lambdas(i) }
       end
     end
+
+    def alpha
+      lambdas.map { |v| v.map { |v2| Math.exp(v2) } }
+    end
   end
 end

data/lib/tomoto/dt.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, timepoint: 0)

data/lib/tomoto/gdmr.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, metadata: [])

data/lib/tomoto/hdp.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
   end
 end

data/lib/tomoto/hlda.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def children_topics(topic_id)
@@ -39,5 +39,18 @@ module Tomoto
       raise "topic_id must be < K" if topic_id >= k
       raise "train() should be called first" unless @prepared
     end
+
+    def topics_info(summary, topic_word_top_n:)
+      counts = count_by_topics
+
+      nested_info = lambda do |k = 0, level = 0|
+        words = topic_words(k, top_n: topic_word_top_n).keys.join(" ")
+        summary << "| #{"  " * level}##{k} (#{counts[k]}) : #{words}"
+        children_topics(k).sort.each do |c|
+          nested_info.call(c, level + 1)
+        end
+      end
+      nested_info.call
+    end
   end
 end

data/lib/tomoto/hpa.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
   end
 end

data/lib/tomoto/lda.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def self.load(filename)
@@ -32,6 +32,42 @@ module Tomoto
       _save(filename, full)
     end
 
+    # returns string instead of printing
+    def summary(initial_hp: true, params: true, topic_word_top_n: 5)
+      summary = []
+
+      summary << "<Basic Info>"
+      basic_info(summary)
+      summary << "|"
+
+      summary << "<Training Info>"
+      training_info(summary)
+      summary << "|"
+
+      if initial_hp
+        summary << "<Initial Parameters>"
+        initial_params_info(summary)
+        summary << "|"
+      end
+
+      if params
+        summary << "<Parameters>"
+        params_info(summary)
+        summary << "|"
+      end
+
+      if topic_word_top_n > 0
+        summary << "<Topics>"
+        topics_info(summary, topic_word_top_n: topic_word_top_n)
+        summary << "|"
+      end
+
+      # skip ending |
+      summary.pop
+
+      summary.join("\n")
+    end
+
     def topic_words(topic_id = nil, top_n: 10)
       if topic_id
         _topic_words(topic_id, top_n)
@@ -40,9 +76,9 @@ module Tomoto
       end
     end
 
-    def train(iterations = 10, workers: 0)
+    def train(iterations = 10, workers: 0, parallel: :default)
       prepare
-      _train(iterations, workers)
+      _train(iterations, workers, to_ps(parallel))
     end
 
     def tw
@@ -64,12 +100,68 @@ module Tomoto
       doc
     end
 
+    def basic_info(summary)
+      sum = used_vocab_freq.sum.to_f
+      mapped = used_vocab_freq.map { |v| v / sum }
+      entropy = mapped.map { |v| v * Math.log(v) }.sum
+
+      summary << "| #{self.class.name.sub("Tomoto::", "")} (current version: #{VERSION})"
+      summary << "| #{num_docs} docs, #{num_words} words"
+      summary << "| Total Vocabs: #{vocabs.size}, Used Vocabs: #{used_vocabs.size}"
+      summary << "| Entropy of words: %.5f" % entropy
+      summary << "| Removed Vocabs: #{removed_top_words.any? ? removed_top_words.join(" ") : "<NA>"}"
+    end
+
+    def training_info(summary)
+      summary << "| Iterations: #{global_step}, Burn-in steps: #{burn_in}"
+      summary << "| Optimization Interval: #{optim_interval}"
+      summary << "| Log-likelihood per word: %.5f" % ll_per_word
+    end
+
+    def initial_params_info(summary)
+      if defined?(@init_params)
+        @init_params.each do |k, v|
+          summary << "| #{k}: #{v}"
+        end
+      else
+        summary << "| Not Available"
+      end
+    end
+
+    def params_info(summary)
+      summary << "| alpha (Dirichlet prior on the per-document topic distributions)"
+      summary << "|  #{alpha}"
+      summary << "| eta (Dirichlet prior on the per-topic word distribution)"
+      summary << "|  %.5f" % eta
+    end
+
+    def topics_info(summary, topic_word_top_n:)
+      counts = count_by_topics
+      topic_words(top_n: topic_word_top_n).each_with_index do |words, i|
+        summary << "| ##{i} (#{counts[i]}) : #{words.keys.join(" ")}"
+      end
+    end
+
+    def to_ps(ps)
+      PARALLEL_SCHEME.index(ps) || (raise ArgumentError, "Invalid parallel scheme: #{ps}")
+    end
+
     class << self
       private
 
       def to_tw(tw)
         TERM_WEIGHT.index(tw) || (raise ArgumentError, "Invalid tw: #{tw}")
       end
+
+      def init_params(model, binding)
+        init_params = {}
+        method(:new).parameters.each do |v|
+          next if v[0] != :key
+          init_params[v[1]] = binding.local_variable_get(v[1]).inspect
+        end
+        model.instance_variable_set(:@init_params, init_params)
+        model
+      end
     end
   end
 end

data/lib/tomoto/llda.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, labels: [])

data/lib/tomoto/mglda.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, delimiter: ".")

data/lib/tomoto/pa.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
   end
 end

data/lib/tomoto/plda.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, labels: [])

data/lib/tomoto/slda.rb

@@ -5,7 +5,7 @@ module Tomoto
       model.instance_variable_set(:@min_cf, min_cf)
       model.instance_variable_set(:@min_df, min_df)
       model.instance_variable_set(:@rm_top, rm_top)
-      model
+      init_params(model, binding)
     end
 
     def add_doc(doc, y: [])

data/lib/tomoto/version.rb

@@ -1,3 +1,3 @@
 module Tomoto
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tomoto
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-10 00:00:00.000000000 Z
+date: 2020-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice