seshbot-packing 0.8.6 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1693c794a4be401fe157bd5a6385e1375e37c738e8919a168cc881ec262f9ec
-  data.tar.gz: 44c25e149bc8dba14cc2cc49f309b5e3ba5901bf4a636f89787ec5e946e28502
+  metadata.gz: 5a3ee88fef7cdb7044eb06951aaee1a388dc499a33226d553ecf1d4af3865df2
+  data.tar.gz: 7ceb6a0a5ad57b515e881352907e42c3bec29330c1055a8947e9662f03ad0ebc
 SHA512:
-  metadata.gz: 59f4cb5bad8c401ef6dde61443937c3bbce68f37f659aef074175a067fd6ea91b346531bc1c809d7b2788a30969eb14c92d8f716fc382d56ac26560cec6c93fd
-  data.tar.gz: c9536fe10e717e4841e8521f5986e467cc0e2b029c3a7512cee255f61941f0d0a5041c6ff0a9a047c218691d9b47ef69b14da6df7227f304cc4eb015f0ba1afa
+  metadata.gz: d7d04a459fbfc6dc06b7b028b535f5a1ab8e87579eb59f3aebc6803d82587abd7582c94074217e6935e189ba56d185138841aca429c3e774ff872c6e82e4a93c
+  data.tar.gz: 030363e4fe38d1f095766f836b86960639e8f3a23cbdde611c3d305cb259315816adc0a488cde7134f778958d3022f19056a0f850244324e0a844bc855195ba9

data/Gemfile

@@ -4,3 +4,5 @@ source "https://rubygems.org"
 gemspec
 gem "rake", "~> 12.0"
 gem "minitest", "~> 5.0"
+
+gem "timecop"

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    seshbot-packing (0.8.6)
+    seshbot-packing (0.9.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     minitest (5.14.2)
     rake (12.3.3)
+    timecop (0.9.4)
 
 PLATFORMS
   ruby
@@ -16,6 +17,7 @@ DEPENDENCIES
   minitest (~> 5.0)
   rake (~> 12.0)
   seshbot-packing!
+  timecop
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -1,5 +1,45 @@
 # Seshbot::Packing
 
+This gem allows inventory to be packed for shipping - used by BrewKeeper for pick/pack logic, and by Carrierbot to aid in calculating 'bundled' shipping rates
+
+## Recipes
+
+The packing rules are described as 'recipes' - one of which is represented as a hash of the format:
+
+```ruby
+{
+  'input_fragment': 'B306',
+  'input_quantity': 1,
+  'output_fragment': 'B301',
+  'output_quantity': '6',
+  'is_reversible': true # optional
+}
+```
+
+The process of packing a collection of line-items in a customer shipment into a smplified set of line-items representing the most cost effective way to pack those items is as follows:
+
+* get all quantity+SKUs in the order/fulfillments in the request
+* unpack as much as possible by:
+** reverse all recipes inputs/outputs
+** find the ‘best’ recipe (the recipe that gives the MOST outputs)
+** repeat until no more unpacking can be done
+* pack as much as possible by:
+** find the ‘best’ recipe (the recipe that gives the FEWEST outputs)
+** repeat until no more packing can be done
+
+Therre area few special considerations:
+- optional `is_reversible` flag: some recipes may not deemed reversible for the 'unpacking' phase; e.g., 3xB306->1xB324. These should be marked as 'is_reversible': false
+- optional `phase` flag: packing recipes may be performed in 'phases' in order to ensure certain rules are adhered to for specific products or variant types (e.g., pack cans into special can-cartons before allowing the remainders to be mixed in with bottles)
+
+Note that if a recipe is found, _it will be applied_ unless a better rule is found.
+
+## Building
+
+* Update the VERSION file
+* `gem build seshbot-packing.gemspec`
+* commit changes
+* `gem push seshbot-packing-VERSION.gem`
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -35,15 +75,15 @@ Seshbot::Packing.count_product_types(items)
 ## returns the hashes where the sku value matches the given string
 items = [{ 'sku' => 'A-C306', 'quantity' => 4, 'price' => 1 },
          { 'sku' => 'A-B306', 'quantity' => 4, 'price' => 1 }]
-Seshbot::Packing.filter_by_sku(items, '-C')
+Seshbot::Packing._filter_by_sku(items, '-C')
 #=> [{ 'sku' => 'A-C306', 'quantity' => 4, 'price' => 1 }]
 ## also takes a named argument
-Seshbot::Packing.filter_by_sku(items, '-C', inverse: true)
+Seshbot::Packing._filter_by_sku(items, '-C', inverse: true)
 #=> [{ 'sku' => 'A-B306', 'quantity' => 4, 'price' => 1 }]
 
 # Substitute SKU
 ## replaces an sku in a hash
-Seshbot::Packing.substitute_sku(items, '-B', '-C')
+Seshbot::Packing._substitute_sku(items, '-B', '-C')
 #=> items = [{"sku" => "A-C306", "quantity" => 2}, {"sku" => "B-C306", "quantity" => 1}]
 ```
 

data/lib/seshbot/packing/line_item.rb

@@ -4,16 +4,38 @@ module Seshbot
   module Packing
     # :nodocs:
     class LineItem
-      attr_accessor :sku, :quantity, :price
+      attr_accessor :sku_fragment, :quantity, :price
 
-      def initialize(sku, quantity, price=0)
-        raise 'SKU must be a string' if sku.class != String
+      def initialize(sku_fragment, quantity, price=0)
+        raise 'SKU fragment must be a string' if sku_fragment.class != String
         raise 'Quantity must be an integer' if quantity.class != Integer
 
-        @sku = sku
+        @sku_fragment = sku_fragment
         @quantity = quantity
         @price = price
       end
+
+      def to_s
+        "#{quantity}x#{sku_fragment}"
+      end
+
+      def self.summarise(items)
+        "#{items.map(&:to_s)}"
+      end
+
+      def self.total_quantity(items)
+        items.map { |i| i.quantity }.sum
+      end
+
+      def self.merge_line_items(items)
+        result = Hash.new(0)
+        # create a hash were the keys are sku_fragment, and the values are the summed quantities
+        items.each do |item|
+          result[item.sku_fragment] += item.quantity
+        end
+        result.delete_if { |k,v| v == 0 }
+        result.map { |sku_fragment, quantity| LineItem.new(sku_fragment, quantity) }
+      end
     end
-  end
-end
+  end # module Packing
+end # module Seshbot

data/lib/seshbot/packing/package.rb

@@ -14,141 +14,156 @@ module Seshbot
         @@logger
       end
 
-      def filter_by_sku(items, sku_fragment, inverse: false)
-        items.select do |i|
-          matches = i.sku.include?(sku_fragment)
-          inverse ? !matches : matches
+      def bundle_items(recipes, items, fulfilled_at: nil)
+        if !fulfilled_at.nil? && fulfilled_at < DateTime.parse('2020-01-14T08:00:00+09:00')
+          logger.debug "== Not Bundling (pre-2020 order) =="
+          return items
         end
-      end
+        is_legacy = _is_legacy(fulfilled_at)
+        is_legacy_str = is_legacy ? " (LEGACY)" : ""
 
-      def substitute_sku(items, from, to)
-        items.map { |i| Seshbot::Packing::LineItem.new(i.sku.gsub(from, to), i.quantity) }
-      end
+        logger.debug "== Bundling Items: #{items.map(&:to_s)}. Fulfilled at: #{fulfilled_at || '(no fulfillment date)'}#{is_legacy_str}"
 
-      def count_product_types(items)
-        result = Hash.new(0)
-        # create a hash were the keys are sku_fragment, and the values are the summed quantities
-        items.each do |item|
-          size = packaged_size(item.sku)
-          result[size] += item.quantity
+        results = []
+
+        if is_legacy
+          results = _bundle_items_legacy(recipes, items)
+        else
+          phases = recipes.values.map { |r| r['phase'] || 0 }.map(&:to_i).uniq.sort
+
+          results = items
+          phases.each do |phase|
+            phase_recipes = recipes.select { |name, recipe| (recipe['phase'] || 0) == phase }.to_h
+
+            logger.debug "=== Bundling phase #{phase}"
+
+            results = _bundle_items_single_phase(phase_recipes, results)
+          end
         end
-        result.map { |k,v| Seshbot::Packing::LineItem.new("BUND-#{k}", v) }
+
+        logger.debug "Bundled result:"
+        logger.debug " - IN: #{items.map(&:to_s)}"
+        logger.debug " - OUT: #{results.map(&:to_s)}"
+
+        results
       end
 
-      def packaged_size(sku)
-        size_regex = /-(K?[LUP]\d{2}|[BCM]\d{3})/
-        match = sku.match(size_regex)
-        raise "Cannot determine packaged size for SKU: #{sku}" if match.nil? || match.captures.empty?
+      def unpack(recipes, items)
+        prev_result = items
 
-        # this is everything inside the (..) in the regex (everything except the leading '-')
-        result = match.captures[0]
-        # HACK! for legacy reasons, we don't consider K to be part of the size.
-        result.gsub!(/^K/, '')
+        (1..1000).each do |i|
+          new_result = _pack_single_step(recipes, prev_result, unpacking: true)
+          is_unchanged = new_result.map { |li| [li.sku_fragment, li.quantity] }.sort == prev_result.map { |li| [li.sku_fragment, li.quantity] }.sort
+          return new_result if is_unchanged
 
-        if result == "B502"
-          result = "B306"
+          prev_result = new_result
         end
-        if result == "B504"
-          result = "B312"
-        end
-        raise "Cannot determine packaged size for SKU: #{sku}" if result.nil?
-
-        result
+        error_message = "could not unpack - infinite loop? (latest: #{prev_result.map(&:to_s)})"
+        logger.error error_message
+        raise error_message
       end
 
-      def bundle_items(recipes, items, fulfilled_at: nil)
-        logger.debug "***** BUNDLING"
-        logger.debug "Bundling Items: #{items}. Fulfilled at: #{fulfilled_at || '(no fulfillment date)'}"
-        if !fulfilled_at.nil? && fulfilled_at < DateTime.new(2020, 1, 14, 8, 0, 0, Time.new.zone)
-          return items
+      def pack(recipes, items)
+        prev_result = items
+
+        # keep trying to 'pack' until it stabilises (e.g., 6x6pack => 1x24pack+2x6pack => 1x24pack+1x12pack)
+        (1..1000).each do |i|
+          new_result = _pack_single_step(recipes, prev_result, unpacking: false)
+          # no changes, break out
+          is_unchanged = new_result.map { |li| [li.sku_fragment, li.quantity] }.sort == prev_result.map { |li| [li.sku_fragment, li.quantity] }.sort
+          return new_result if is_unchanged
+
+          prev_result = new_result
         end
+        error_message = "could not pack - infinite loop? (latest: #{prev_result.map(&:to_s)})"
+        logger.error error_message
+        raise error_message
+      end
+
+      #
+      # private
+      #
+
+      def _is_legacy(fulfilled_at)
+        effective_fulfilled_at = fulfilled_at.nil? ? DateTime.now : fulfilled_at
+        is_legacy = effective_fulfilled_at < DateTime.parse('2021-04-07T09:00:00+09:00')
+        is_legacy
+      end
 
+      def _bundle_items_legacy(recipes, items)
         # get the cans first, and separate them out
-        cans = filter_by_sku(items, '-C')
+        cans = _filter_by_sku_fragment_prefix(items, 'C')
+        remaining_cans = []
         unless cans.empty?
-          bundle_items_by_type = count_product_types(cans)
+          bundle_items_by_type = LineItem.merge_line_items(cans)
           bundle_items_by_type = unpack(recipes, bundle_items_by_type)
           new_can_items = pack(recipes, bundle_items_by_type)
           # separate out all the C324s
-          separated_c324s = filter_by_sku(new_can_items, '-C324')
-          logger.debug "Cans: #{cans}"
-          logger.debug " - Removed C324s: #{separated_c324s}"
+          separated_c324s = _filter_by_sku_fragment_prefix(new_can_items, 'C324')
+          logger.debug "Cans: #{cans.map(&:to_s)}"
+          logger.debug " - Removed C324s: #{separated_c324s.map(&:to_s)}"
 
-          remaining_cans = filter_by_sku(new_can_items, '-C324', inverse: true)
-          logger.debug " - Remaining skus: #{remaining_cans}"
+          remaining_cans = _filter_by_sku_fragment_prefix(new_can_items, 'C324', inverse: true)
+          logger.debug " - Remaining skus: #{remaining_cans.map(&:to_s)}"
         end
 
         # merge the remaining with the original leftover
-        non_cans = filter_by_sku(items, '-C', inverse: true)
-        remaining_cans ||= []
+        non_cans = _filter_by_sku_fragment_prefix(items, 'C', inverse: true)
         remaining_items = non_cans + remaining_cans
         logger.debug "Substituting:"
-        logger.debug " - remaining items: #{remaining_items}"
+        logger.debug " - remaining items: #{remaining_items.map(&:to_s)}"
 
         # substitute C's for B's
-        remaining_items = substitute_sku(remaining_items, '-C', '-B')
-        logger.debug " - skus updated to: #{remaining_items}"
+        remaining_items = _substitute_sku(remaining_items, /^C/, 'B')
+        logger.debug " - skus updated to: #{remaining_items.map(&:to_s)}"
 
         # get a hash of {pack_6: 5, pack_12: 1}
-        bundle_items_by_type = count_product_types(remaining_items)
+        bundle_items_by_type = LineItem.merge_line_items(remaining_items)
         # dismantle packages into individual units (e.g., {pack_6: 7})
         bundle_items_by_type = unpack(recipes, bundle_items_by_type)
         # repackage into the 'best' packaging we can figure out (e.g., {pack_12: 2})
         new_remaining_items = pack(recipes, bundle_items_by_type)
 
         separated_c324s ||= []
-        merged_items = new_remaining_items + separated_c324s
-        logger.debug "Bundled result:"
-        logger.debug " - IN: #{items}"
-        logger.debug " - OUT: #{merged_items}"
-        merged_items
-      end
+        results = new_remaining_items + separated_c324s
 
-      def unpack(recipes, items)
-
-        final_result = items
-
-        loop do
-          new_result = pack_single_step(recipes, final_result, unpacking: true)
-          break if new_result.map { |li| [li.sku, li.quantity] }.sort == final_result.map { |li| [li.sku, li.quantity] }.sort
-
-          final_result = new_result
-        end
-        final_result
+        results
       end
 
-      def pack_single_step(recipes, items, unpacking:)
-        result = Hash.new(0)
-        items.each do |item|
-          sku_size = packaged_size(item.sku)
-          recipe = Recipe::find_best_recipe(recipes, sku_size, item.quantity, unpacking: unpacking)
-          if recipe.nil?
-            result[sku_size] += item.quantity
-            next
-          end
+      def _bundle_items_single_phase(recipes, items)
+        # get a list of items merged together by variant type (e.g., 10xBIGI-C301 + 5xBISS-C301 => 15xBUND-C301))
+        merged_items = LineItem.merge_line_items(items)
+        # dismantle packages into individual units
+        unpacked_items = unpack(recipes, merged_items)
+        # repackage into the 'best' packaging we can figure out
+        pack(recipes, unpacked_items)
+      end
 
-          recipe_quantities = Recipe::apply_recipe(recipe, item.quantity)
-          result[recipe["input_fragment"]] += recipe_quantities[:input_quantity]
-          result[recipe["output_fragment"]] += recipe_quantities[:output_quantity]
+      def _filter_by_sku_fragment_prefix(items, sku_fragment, inverse: false)
+        items.select do |i|
+          matches = i.sku_fragment.start_with? sku_fragment
+          inverse ? !matches : matches
         end
-        result.delete_if { |k,v| v == 0}
-        result.map { |k,v| Seshbot::Packing::LineItem.new("BUND-#{k}", v) }
       end
 
+      def _substitute_sku(items, re, sub)
+        items.map { |i| LineItem.new(i.sku_fragment.gsub(re, sub), i.quantity) }
+      end
 
-      def pack(recipes, items)
-        final_result = items
-
-        # keep trying to 'pack' until it stabilises (e.g., 6x6pack => 1x24pack+2x6pack => 1x24pack+1x12pack)
-        loop do
-          new_result = pack_single_step(recipes, final_result, unpacking: false)
-          # no changes, break out
-          break if new_result.map { |li| [li.sku, li.quantity] }.sort == final_result.map { |li| [li.sku, li.quantity] }.sort
-
-          final_result = new_result
+      def _pack_single_step(recipes, items, unpacking:)
+        recipe = Recipe::find_best_recipe(recipes, items, unpacking: unpacking)
+        if recipe.nil?
+          # its as packed/unpacked as it can get
+          return items
         end
-        final_result
+
+        before = LineItem::summarise(items)
+        items = Recipe::apply_recipe(recipe, items)
+        after = LineItem::summarise(items)
+        logger.debug "applying recipe (#{unpacking ? 'unpacking' : 'packing'}) #{Recipe::summarise(recipe)}: #{before} -> #{after}"
+        items
       end
-    end
-  end
-end
+
+    end # class << self
+  end # module Packing
+end # module Seshbot

data/lib/seshbot/packing/recipe.rb

@@ -2,59 +2,127 @@ module Seshbot
   module Packing
     module Recipe
       class << self
-        def find_best_recipe(recipes_hash, sku_fragment, qty, unpacking: false)
-          recipes = find_recipes(recipes_hash, sku_fragment, qty, unpacking: unpacking)
-          # we want the recipe that is 'best' (packaging into as few items as possible, or unpacaging into as many as possible)
-          best_recipe_quantities = nil
-          recipes.each do |name, recipe|
-            recipe_quantities = apply_recipe(recipe, qty)
+        def find_best_recipe(recipes_hash, items, unpacking: false)
+          recipes = _find_recipes(recipes_hash, items, unpacking: unpacking)
 
-            # if there was no 'best' until now, just set it (makes the next step a bit simpler)
-            best_recipe_quantities ||= recipe_quantities
+          # we want the recipe that is 'best' (packaging into as few items as possible, or unpacaging into as many as possible)
+          best_recipe = nil
+          best_recipe_output_quantity = nil
+          recipes.each do |recipe_name, recipe|
+            recipe_factor = _calculate_recipe_factor(recipe, items)
+            recipe_output_quantity = recipe_factor * recipe['output_quantity']
 
             # is this recipe the 'best'? (if packaging, best is the one that creates fewest quantity)
-            is_best = unpacking ?
-                        recipe_quantities[:output_quantity] > best_recipe_quantities[:output_quantity] :
-                        recipe_quantities[:output_quantity] < best_recipe_quantities[:output_quantity]
+            is_best = if best_recipe_output_quantity.nil?
+              true
+            else
+              unpacking ?
+                  recipe_output_quantity > best_recipe_output_quantity :
+                  recipe_output_quantity < best_recipe_output_quantity
+            end
 
             if is_best
-              best_recipe_quantities = recipe_quantities
+              best_recipe_output_quantity = recipe_output_quantity
+              best_recipe = recipe
             end
           end
-          best_recipe_quantities[:recipe] if best_recipe_quantities
+          best_recipe
         end
 
-        def find_recipes(recipes, sku_fragment, qty, unpacking: false)
-          recipes = reverse_recipes(recipes) if unpacking
-          recipes.select do |name, recipe|
-            recipe["input_fragment"] == sku_fragment && qty >= recipe["input_quantity"]
+        def apply_recipe(recipe, items)
+          factor = _calculate_recipe_factor(recipe, items)
+
+          # shortcut - cannot apply recipe, not enough inputs
+          return items if factor == 0
+
+          results = items.dup
+
+          # first remove inputs (add negative quantities)
+          recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
+          recipe_inputs.each do |inputs|
+            results << LineItem.new(inputs['input_fragment'], -1 * inputs['input_quantity'] * factor)
           end
-          # recipes.select { |name, recipe| recipe[:input_fragment] == sku_fragment && qty >= recipe[:input_quantity] }
+
+          # now add input
+          results << LineItem.new(recipe['output_fragment'], recipe['output_quantity'] * factor)
+
+          # consolidate 
+          results = LineItem.merge_line_items(results)
         end
 
-        def reverse_recipes(recipes)
-          results = recipes.map do |recipe_name, recipe_details|
+        def summarise(recipe)
+          recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
+          inputs = recipe_inputs.map { |i| "#{i['input_quantity']}x#{i['input_fragment']}" }.join(',')
+          outputs = "#{recipe['output_quantity']}x#{recipe['output_fragment']}"
+          "#{inputs} -> #{outputs}"
+        end
+
+        #
+        # private
+        #
+
+        def _calculate_recipe_factor(recipe, items)
+          recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
+
+          recipe_input_factors = recipe_inputs.map do |inputs|
+            input_fragment = inputs['input_fragment']
+            input_quantity = inputs['input_quantity']
+
+            item = items.find { |i| i.sku_fragment == input_fragment }
+            raise "recipe contains items not present in order (#{input_fragment})" if item.nil?
+
+            [inputs, item.quantity / input_quantity]
+          end
+
+          recipe_input_factors.map { |i,f| f }.min
+        end
+
+        def _find_recipes(recipes, items, unpacking: false)
+          recipes = _reverse_recipes(recipes) if unpacking
+          recipes.select do |recipe_name, recipe_details|
+            recipe_inputs = recipe_details['inputs'].nil? ? [recipe_details] : recipe_details['inputs']
+
+            # recipe is a candidate if all inputs may be satisfied by available items
+            recipe_inputs.all? do |inputs|
+              items.any? { |i| inputs["input_fragment"] == i.sku_fragment && i.quantity >= inputs["input_quantity"] }
+            end
+          end
+        end
+
+        def _reverse_recipes(recipes)
+          # first exclude recipes that are explicitly configured as not reversible
+          reversible_recipes = recipes.select do |recipe_name, recipe_details|
+            recipe_details['is_reversible'].nil? || recipe_details['is_reversible']
+          end
+
+          unique_reversible_output_fragments = reversible_recipes.values.map { |r| r['output_fragment'] }.sort.uniq
+
+          # further refine by excluding recipes that are technically incapable of being reversed
+          reversible_recipes = reversible_recipes.select do |recipe_name, recipe_details|
+            # currently dont support multipe outputs, so cannot reverse recipes with multiple inputs
+            is_composite = !recipe_details['inputs'].nil? && recipe_details['inputs'].length != 1
+            # cannot reverse recipes where there are multipe ways of creating the same output
+            is_ambiguous = !unique_reversible_output_fragments.include?(recipe_details['output_fragment'])
+
+            !is_composite && !is_ambiguous
+          end
+
+          results = reversible_recipes.map do |recipe_name, recipe_details|
+            # here we know that if 'inputs' is specified it will have exactly 1 input
+            input_fragment = recipe_details["input_fragment"] || recipe_details["inputs"][0]["input_fragment"]
+            input_quantity = recipe_details["input_quantity"] || recipe_details["inputs"][0]["input_quantity"]
+
             new_recipe_details = {
               "input_fragment" => recipe_details["output_fragment"],
               "input_quantity" => recipe_details["output_quantity"],
-              "output_fragment" => recipe_details["input_fragment"],
-              "output_quantity" => recipe_details["input_quantity"]
+              "output_fragment" => input_fragment,
+              "output_quantity" => input_quantity
             }
             [recipe_name, new_recipe_details]
           end
           results.to_h
         end
-
-        def apply_recipe(recipe, input_quantity)
-          multiplier, remainder = input_quantity.divmod(recipe["input_quantity"])
-          {
-            recipe: recipe,
-            input_quantity: remainder,
-            output_quantity: multiplier * recipe["output_quantity"]
-          }
-        end
-
-      end
-    end
-  end
-end
+      end # class << self
+    end # module Recipe
+  end # module Packing
+end # module Seshbot

data/lib/seshbot/packing/version.rb

@@ -1,5 +1,5 @@
 module Seshbot
   module Packing
-    VERSION = '0.8.6'
+    VERSION = '0.9.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seshbot-packing
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.9.1
 platform: ruby
 authors:
 - Shaun
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-31 00:00:00.000000000 Z
+date: 2021-04-07 00:00:00.000000000 Z
 dependencies: []
 description:
 email: