trials 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0faac0139726fc3797359f6d89582fcc463721378f4614f711b97d4de0f7850b
+  data.tar.gz: bf7c8ad2165fb67eedaf1b0c5c78f15af345f17a4a064b36a452e850d672afe3
+SHA512:
+  metadata.gz: b691fe13f902bc121b4ba85a0350d077682d73d3119beba04cc4a788a891c94eb9d208a76e5b9af8b59e880c421b51fd30b672bb7ed2845569e86ec938a2cef5
+  data.tar.gz: 80a851272d8ed0b997df0e3a5f10c257acf73fd2cf07c9373c0cc5c26dfb1d7d473a4a6da7f08ebcd72ddf475d4d011cf86f9937cdd477a27ccedf195e184c33

data/bin/trial

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/trials'
+
+# env
+START_TIME = Time.now
+SCRIPT_NAME = ARGV[0].gsub('.rb', '')
+RUN = "#{START_TIME.strftime("%Y%m%dT%H%M%S")}_#{SCRIPT_NAME}"
+ROOT = Dir.pwd
+SECRETS = OpenStruct.new
+
+if File.exists?(File.expand_path('~/.trials/secrets.yml'))
+  JSON.parse(
+    YAML.load_file(File.expand_path('~/.trials/secrets.yml')).to_json,
+    object_class: OpenStruct,
+  )
+end
+
+# init standard dirs
+FileUtils.mkdir_p("seeds")
+FileUtils.mkdir_p("results/#{RUN}")
+FileUtils.mkdir_p("tmp")
+
+# log start
+log "starting #{SCRIPT_NAME} at #{START_TIME.iso8601}"
+log nil
+
+# run script
+load "#{SCRIPT_NAME}.rb"
+
+# log end
+END_TIME = Time.now
+log nil
+log "done at #{END_TIME.iso8601}, took #{(END_TIME - START_TIME).round(4)}s"

data/lib/trials.rb

@@ -0,0 +1,36 @@
+require 'active_support/all'
+require 'aws-sdk-dynamodb'
+require 'benchmark'
+require 'csv'
+require 'fileutils'
+require 'fuzzy_match'
+require 'google_drive'
+require 'namae'
+require 'nokogiri'
+require 'ostruct'
+require 'pp'
+require 'pry'
+require 'rest-client'
+require 'set'
+require 'smalltext'
+require 'sqlite3'
+require 'street_address'
+require 'tty-table'
+require 'yaml'
+
+require_relative 'trials/utils/various'
+require_relative 'trials/utils/csvs'
+require_relative 'trials/utils/hashes'
+require_relative 'trials/utils/logging'
+require_relative 'trials/utils/strings'
+require_relative 'trials/utils/files'
+require_relative 'trials/utils/jsons'
+require_relative 'trials/utils/sqls'
+require_relative 'trials/utils/pdfs'
+require_relative 'trials/utils/xmls'
+require_relative 'trials/utils/benchmarking'
+require_relative 'trials/utils/rollbar'
+require_relative 'trials/utils/aws'
+require_relative 'trials/utils/google_drive'
+require_relative 'trials/data_handling/addresses'
+require_relative 'trials/data_handling/names'

data/lib/trials/data_handling/addresses.rb

@@ -0,0 +1,37 @@
+# normal format <number> <STREET NAME>, <CITY>, <STATE> <postal>
+
+def normalize_address(address)
+  return if address.blank?
+
+  cleaner_string = if address.respond_to?(:address1)
+    "#{address.address1}, #{address.city}, #{address.state} #{address.postal_code}"
+  else
+    address
+  end
+
+  cleaner_string = cleaner_string.gsub('#', ' #').squish
+  parsed = StreetAddress::US.parse(cleaner_string)
+
+  return if parsed.blank?
+  return if parsed.number.blank?
+  return if parsed.street.blank?
+  return if parsed.city.blank?
+  return if parsed.state.blank?
+  return if parsed.postal_code.blank?
+
+  parsed.prefix = nil
+  parsed.suffix = nil
+  parsed.unit_prefix = nil
+  parsed.unit = nil
+  parsed.postal_code_ext = nil
+
+  parsed.to_s.upcase
+end
+
+def parse_address(address_string)
+  StreetAddress::US.parse(address_string)
+end
+
+def normalize_and_parse_address(address_string)
+  StreetAddress::US.parse(normalize_address(address_string))
+end

data/lib/trials/data_handling/names.rb

@@ -0,0 +1,84 @@
+# normal <FIRST> <LAST>
+
+Name = Struct.new(:first_name, :middle_name, :last_name)
+
+class NamePartsParser
+  def initialize(name_string)
+    @namae = Namae.parse((name_string || '').upcase).first
+  end
+
+  def first
+    normalize_name(split_first_and_middle(given).first)
+  end
+
+  def middle
+    normalize_name(split_first_and_middle(given).last)
+  end
+
+  def last
+    normalize_name(family)
+  end
+
+  private
+
+  def given
+    @namae&.given || ''
+  end
+
+  def family
+    @namae&.family || ''
+  end
+
+  def split_first_and_middle(first_and_middle)
+    names = first_and_middle.split(' ', 2)
+    names.length == 1 ? names + [''] : names
+  end
+end
+
+def normalize_name(name)
+  return if name.blank?
+
+  name = name_from_parts(name) if name.respond_to?(:first_name)
+
+  name.strip.upcase.delete('^A-Z\ \-').squeeze(" ")
+end
+
+def normalize_full_names(names)
+  Array.wrap(names)
+    .map { |n| normalize_full_name(n) }
+    .map(&:to_s)
+    .map(&:presence)
+    .compact
+    .uniq
+end
+
+def normalize_full_name(name)
+  return if name.blank?
+
+  name.strip.upcase.delete('^A-Z\ \-').squeeze(" ")
+end
+
+def parse_name(name)
+  NamePartsParser.new(name)
+end
+
+def normalize_and_parse_name(name)
+  NamePartsParser.new(normalize_name(name))
+end
+
+# private
+
+def name_from_parts(name)
+  first = normalize_name_part(name.first_name)
+  last = normalize_name_part(name.last_name)
+
+  [first, last].join(' ')
+end
+
+def full_name_from_parts(name)
+  first = normalize_name_part(name.first_name)
+  middle = normalize_name_part(name.middle_name)
+  last = normalize_name_part(name.last_name)
+
+  [first, middle, last].join(' ')
+end

data/lib/trials/utils/aws.rb

@@ -0,0 +1,67 @@
+def ddb_connection
+  @connection ||= Aws::DynamoDB::Client.new(
+    access_key_id: secrets.aws.key,
+    secret_access_key: secrets.aws.secret,
+    region: secrets.aws.region,
+  )
+end
+
+def cached_ddb_scan(query)
+  json_cache(query.dig(:table_name)) { ddb_scan(query) }
+end
+
+def ddb_scan(query)
+  segmentation = query.delete(:segmentation) || 4
+
+  threads = (0..segmentation - 1).map do |segment|
+    Thread.new do
+      Thread.current[:output] = ddb_scan_without_segmentation(
+        query.merge(
+          total_segments: segmentation,
+          segment: segment,
+        ),
+      )
+    end
+  end
+
+  threads.each(&:join)
+
+  threads.map { |t| t[:output] }.flatten
+end
+
+def ddb_scan_without_segmentation(query)
+  result = nil
+  requests = 0
+  items = []
+
+  loop do
+    break unless result.blank? || result.last_evaluated_key.present?
+
+    result = ddb_connection.scan(query.merge(exclusive_start_key: result&.last_evaluated_key))
+    items += result.items.compact.map(&:symbolize_keys)
+  end
+
+  items
+end
+
+def ddb_upload_items(table, all_items)
+  all_items.each_slice(25).with_index do |items, i|
+    next unless items.any?
+
+    begin
+      ddb_connection.batch_write_item(
+        request_items: {
+          table => items.compact.map do |item|
+            {
+              put_request: {
+                item: item
+              }
+            }
+          end
+        }
+      )
+    end
+
+    yield(items, i * 25) if block_given?
+  end
+end

data/lib/trials/utils/benchmarking.rb

@@ -0,0 +1,3 @@
+def timeit
+  log(Benchmark.measure { yield }.to_s)
+end

data/lib/trials/utils/csvs.rb

@@ -0,0 +1,19 @@
+def read_csv(filename)
+  CSV
+    .foreach(seeds_path(filename), headers: true)
+    .map(&:to_h)
+    .map(&:symbolize_keys)
+    .select { |i| i.values.any?(&:present?) }
+end
+
+def write_csv_from_hashes(file, hash_set, attrs: nil)
+  attrs ||= uniq_hash_keys(hash_set)
+
+  CSV.open(results_path(file), 'w') do |csv|
+    csv << attrs
+
+    hash_set.each do |c|
+      csv << attrs.map { |a| c.send(:dig, a) }
+    end
+  end
+end

data/lib/trials/utils/files.rb

@@ -0,0 +1,110 @@
+# paths
+
+def seeds_path(name)
+  "#{ROOT}/seeds/#{name}"
+end
+
+alias seed_path seeds_path
+
+def seed_exists?(name)
+  File.exist?(seed_path(name))
+end
+
+alias seeds_exist? seed_exists?
+
+def results_path(name)
+  "#{ROOT}/results/#{RUN}/#{name}"
+end
+
+alias result_path results_path
+
+def result_exists?(name)
+  File.exist?(result_path(name))
+end
+
+alias results_exist? result_exists?
+
+def tmp_path(name)
+  "#{ROOT}/tmp/#{name}"
+end
+
+def tmp_exists?(name)
+  File.exist?(tmp_path(name))
+end
+
+def list_dir(dir)
+  Dir["#{seeds_path(dir)}/**/*"]
+end
+
+# reading
+
+def read(file)
+  return unless seed_exists?(file)
+  File.read(seeds_path(file))
+end
+
+alias read_seed read
+alias read_seeds read
+
+def read_tmp(file)
+  return unless tmp_exists?(file)
+  File.read(tmp_path(file))
+end
+
+def readlines(file)
+  File.read(seeds_path(file)).split("\n")
+end
+
+# writing
+
+def write(file, content)
+  FileUtils.mkdir_p(File.dirname(results_path(file)))
+  File.open(results_path(file), 'w') { |f| f << content }
+end
+
+alias write_result write
+alias write_results write
+
+def write_tmp(file, content)
+  FileUtils.mkdir_p(File.dirname(tmp_path(file)))
+  File.open(tmp_path(file), 'w') { |f| f << content }
+end
+
+def append(file, content)
+  File.open(results_path(file), 'a') { |f| f << content }
+end
+
+alias append_result append
+alias append_results append
+
+# deleting
+
+def delete(file)
+  return unless result_exists?(file)
+  FileUtils.rm_r(results_path(file))
+end
+
+alias delete_result delete
+alias delete_results delete
+
+def delete_tmp(file)
+  return unless tmp_exists?(file)
+  FileUtils.rm_r(tmp_path(file))
+end
+
+def delete_seeds(file)
+  return unless seed_exists?(file)
+  FileUtils.rm_r(seeds_path(file))
+end
+
+alias delete_seed delete_seeds
+
+# other
+
+def make_seed(file)
+  FileUtils.cp(results_path(file), seeds_path(file))
+end
+
+def make_tmp(file)
+  FileUtils.cp(results_path(file), tmp_path(file))
+end

data/lib/trials/utils/google_drive.rb

@@ -0,0 +1,8 @@
+def gd_session
+  @gd_session ||= begin
+    write('config.json', secrets.google.drive_config_json)
+    session = GoogleDrive::Session.from_config(results_path("config.json"))
+    delete('config.json')
+    session
+  end
+end

data/lib/trials/utils/hashes.rb

@@ -0,0 +1,90 @@
+def uniq_hash_keys(hashes)
+  hashes.flat_map(&:keys).uniq.compact
+end
+
+def sanitize_hash_value(hash, key:, type:, date_format: '%Y-%m-%d')
+  hash.merge(
+    key => or_nil do
+      case type
+      when :date
+        Date.strptime(hash.dig(key), date_format)
+      when :datetime
+        DateTime.parse(hash.dig(key))
+      when :integer, :int
+        hash.dig(key).to_i
+      when :float
+        hash.dig(key).to_f
+      when :string
+        hash.dig(key).to_s
+      when :alphanum
+        string_to_alphanum(hash.dig(key))
+      when :present?
+        hash.dig(key).present?
+      end
+    end
+  )
+end
+
+def sanitize_hash_values(hash, scheme = {})
+  scheme.each do |k, v|
+    hash = sanitize_hash_value(hash, key: k, type: v)
+  end
+
+  hash
+end
+
+def rename_hash_key(hash, from:, to:)
+  hash[to] = hash.delete(from)
+  hash
+end
+
+def rename_hash_keys(hash, scheme = {})
+  scheme.each do |k, v|
+    hash = rename_hash_key(hash, from: k, to: v)
+  end
+
+  hash
+end
+
+def merge_hash_groups(*groups, key:, join_type: :inner)
+  groups = groups.map { |group| group.map { |g| [g.dig(key), g] }.to_h }
+
+  keys = begin
+    case join_type
+    when :inner
+      groups.map(&:keys).reduce(&:&)
+    when :all
+      groups.flat_map(&:keys).uniq
+    when :first
+      groups.first.keys
+    end
+  end
+
+  keys.map { |key| groups.map { |g| g.dig(key) }.compact.reduce(&:merge) }
+end
+
+def count_for_group_by(batch, &block)
+  batch
+    .group_by(&block)
+    .map { |k, v| [k, v.length] }
+    .to_h
+end
+
+def array_to_count_hash(list)
+  list.uniq.reduce({}) do |h, i|
+    h[i] = list.count(i)
+    h
+  end
+end
+
+def update_counts_hash(counts, update)
+  update.each do |k, v|
+    if counts.key?(k)
+      counts[k] += v
+    else
+      counts[k] = v
+    end
+  end
+
+  counts
+end

data/lib/trials/utils/jsons.rb

@@ -0,0 +1,22 @@
+def read_json(filename)
+  result = JSON.parse(read(filename))
+
+  aggressive_deep_symbolize_keys(result)
+end
+
+def write_hashes_to_json(file, hashes)
+  write(file, hashes.to_json)
+end
+
+def json_cache(key)
+  name = "json/#{key}.json"
+
+  return aggressive_deep_symbolize_keys(JSON.parse(read_tmp(name))) if tmp_exists?(name)
+
+  write_tmp(name, yield.to_json)
+  json_cache(key)
+end
+
+def invalidate_json_cache
+  delete_tmp("json")
+end

data/lib/trials/utils/logging.rb

@@ -0,0 +1,42 @@
+def render_table_from_hashes(hash_set, sort: true, headers: nil)
+  return 'no data' if hash_set.blank?
+
+  headers = headers || uniq_hash_keys(hash_set)
+
+  headers.sort! if sort
+
+  content = hash_set
+    .map { |h| h.select { |k, v| v.present? }.to_h }
+    .map { |hash| headers.map { |h| hash.dig(h) } }
+    .map { |r| r.map(&:to_s) }
+
+  TTY::Table.new(header: headers, rows: content).render(:unicode).to_s
+end
+
+def log(item, nl: true, quiet: false, each: true)
+  item ||= ''
+
+  if each && item.is_a?(Array)
+    item.each { |i| log(i, nl: nl, quiet: quiet, each: false) }
+    return
+  end
+
+  File.open(results_path('log.txt'), 'a') do |f|
+    f << begin
+      if item.is_a?(String) || item.is_a?(Numeric)
+        item.to_s
+      else
+        PP.pp(item, '').chomp
+      end
+    end
+
+    f << "\n" if nl
+  end
+
+  print item unless quiet
+  puts '' if nl
+end
+
+def l(item, nl: true, quiet: false)
+  log(item, nl: nl, quiet: quiet, each: false)
+end

data/lib/trials/utils/pdfs.rb

@@ -0,0 +1,4 @@
+def pdf_to_text(path)
+  `pdftotext "#{seeds_path(path)}" #{tmp_path('tmp_pdf.txt')}; \
+  cat #{tmp_path('tmp_pdf.txt')}`
+end

data/lib/trials/utils/rollbar.rb

@@ -0,0 +1,26 @@
+def get_single_rollbar_items_page(token:, page:, status: 'active')
+  url = URI("https://api.rollbar.com/api/1/instances/?access_token=#{token}&page=#{page}&status=#{status}")
+  http = Net::HTTP.new(url.host, url.port)
+  http.use_ssl = true
+  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  request = Net::HTTP::Get.new(url)
+  JSON.parse(http.request(request).body).deep_symbolize_keys.dig(:result, :instances)
+end
+
+def get_rollbar_items(token:, status: 'active')
+  current_page = 0
+  items = []
+
+  loop do
+    single_page_of_items = get_single_rollbar_items_page(token: token, page: current_page, status: status)
+
+    items += single_page_of_items
+
+    break if single_page_of_items.empty?
+    break if yield(current_page, items)
+
+    current_page += 1
+  end
+
+  items.compact.uniq
+end

data/lib/trials/utils/sqls.rb

@@ -0,0 +1,70 @@
+def hashes_to_sql_temp_table(hashes)
+  attrs = uniq_hash_keys(hashes)
+
+  attr_chars = attrs
+    .map { |a| "#{a} varchar" }
+    .join(', ')
+
+  value_tuples = hashes
+    .map { |s| '(' + attrs.map { |a| "'#{s.dig(a) }'" }.join(', ') + ')' }
+    .join(",\n")
+
+  <<~SQL
+    create temp table seed_data (
+      #{attr_chars}
+    );
+
+    insert into seed_data values
+    #{value_tuples};
+  SQL
+end
+
+def create_db(name)
+  db_loc = results_path("#{name}.db")
+
+  raise 'db already exists' if File.exist?(db_loc)
+
+  db = SQLite3::Database.new(db_loc)
+  db.results_as_hash = true
+  db
+end
+
+def use_db(name)
+  db_loc = seeds_path("#{name}.db")
+
+  raise 'no db exists' unless File.exist?(db_loc)
+
+  db = SQLite3::Database.new(db_loc)
+  db.results_as_hash = true
+  db
+end
+
+def create_table(db, table, **attrs)
+  should_log = attrs.delete(:log)
+  attrs = attrs.map { |k, v| "  #{k} #{v}" }.join(",\n")
+  sql = <<~SQL
+    create table #{table} (
+    #{attrs}
+    );
+  SQL
+
+  log sql if should_log
+  db.execute sql
+end
+
+def insert_into_db(db, table, **attrs)
+  should_log = attrs.delete(:log)
+  keys_group = "(#{attrs.keys.join(', ')})"
+  values_group = "(#{(['?'] * attrs.values.length).join(', ')})"
+  sql = <<~SQL
+    insert into #{table} #{keys_group}
+    values #{values_group}
+  SQL
+
+  log sql if should_log
+  db.execute sql, attrs.values
+end
+
+def query_db(db, query)
+  db.execute(query)
+end

data/lib/trials/utils/strings.rb

@@ -0,0 +1,11 @@
+def normalize_string(string)
+  string.chomp.strip.squish
+end
+
+def string_to_alphanum(string)
+  string.gsub(/[^A-Za-z0-9]/, '')
+end
+
+def string_encode_utf_8(string)
+  string.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+end

data/lib/trials/utils/various.rb

@@ -0,0 +1,21 @@
+def secrets
+  SECRETS
+end
+
+def or_nil
+  val = yield
+  raise if val.blank? || val == 0
+  val
+rescue StandardError
+end
+
+def float?(string)
+  true if Float(string) rescue false
+end
+
+def aggressive_deep_symbolize_keys(maybe)
+  return maybe.deep_symbolize_keys if maybe.respond_to?(:deep_symbolize_keys)
+  return maybe.map { |i| aggressive_deep_symbolize_keys(i) } if maybe.respond_to?(:each)
+
+  maybe
+end

data/lib/trials/utils/xmls.rb

@@ -0,0 +1,11 @@
+def hash_from_xml(str)
+  Hash.from_xml(clean_xml(str)).deep_symbolize_keys
+end
+
+def prettify_xml(str)
+  Nokogiri::XML(str) { |c| c.default_xml.noblanks }.to_xml(indent: 2)
+end
+
+def clean_xml(str)
+  Nokogiri::XML(str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')).to_xml
+end

metadata

@@ -0,0 +1,327 @@
+--- !ruby/object:Gem::Specification
+name: trials
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- grahamotte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-dynamodb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fuzzy_match
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: google_drive
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: namae
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: smalltext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: street_address
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables:
+- trial
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/trial
+- lib/trials.rb
+- lib/trials/data_handling/addresses.rb
+- lib/trials/data_handling/names.rb
+- lib/trials/utils/aws.rb
+- lib/trials/utils/benchmarking.rb
+- lib/trials/utils/csvs.rb
+- lib/trials/utils/files.rb
+- lib/trials/utils/google_drive.rb
+- lib/trials/utils/hashes.rb
+- lib/trials/utils/jsons.rb
+- lib/trials/utils/logging.rb
+- lib/trials/utils/pdfs.rb
+- lib/trials/utils/rollbar.rb
+- lib/trials/utils/sqls.rb
+- lib/trials/utils/strings.rb
+- lib/trials/utils/various.rb
+- lib/trials/utils/xmls.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: gem for testing out ideas quickly
+test_files: []