artbase 0.0.1 → 0.1.0

data/lib/artbase/image/24x24.rb

@@ -0,0 +1,68 @@
+
+
+PIXEL_OFFSETS['24x24'] = {
+  ######################
+  #  269x269  (24x24)
+  #    assume 11px per pixel 11x24 = 264 + 5 = 269
+  #
+  #   e.g.   24.times {|i| puts "#{(5+i*11+5.0/24.0*i).to_i} => #{i}," }
+  '269x269' =>  {
+    5 => 0,
+    16 => 1,
+    27 => 2,
+    38 => 3,
+    49 => 4,
+    61 => 5,
+    72 => 6,
+    83 => 7,
+    94 => 8,
+    105 => 9,
+    117 => 10,
+    128 => 11,
+    139 => 12,
+    150 => 13,
+    161 => 14,
+    173 => 15,
+    184 => 16,
+    195 => 17,
+    206 => 18,
+    217 => 19,
+    229 => 20,
+    240 => 21,
+    251 => 22,
+    262 => 23,
+    },
+
+
+  ######################
+  #  512x512  (24x24)
+  #    assume 21px per pixel 21x24 = 504 + 8 = 512
+  #
+  #   e.g.   24.times {|i| puts "#{(12+i*21+8.0/24.0*i).to_i} => #{i}," }
+  '512x512' =>  {
+        12 => 0,
+        33 => 1,
+        54 => 2,
+        76 => 3,
+        97 => 4,
+        118 => 5,
+        140 => 6,
+        161 => 7,
+        182 => 8,
+        204 => 9,
+        225 => 10,
+        246 => 11,
+        268 => 12,
+        289 => 13,
+        310 => 14,
+        332 => 15,
+        353 => 16,
+        374 => 17,
+        396 => 18,
+        417 => 19,
+        438 => 20,
+        460 => 21,
+        481 => 22,
+        502 => 23,
+  },
+}

data/lib/artbase/image/32x32.rb

@@ -0,0 +1,43 @@
+
+PIXEL_OFFSETS['32x32'] = {
+    ######################
+    #  320x320  (32x32)
+    #    assume 10px per pixel 10x32 = 320
+    #
+    #   e.g.   32.times {|i| puts "#{5+i*10} => #{i}," }
+    '320x320'  =>  {
+      5 => 0,
+      15 => 1,
+      25 => 2,
+      35 => 3,
+      45 => 4,
+      55 => 5,
+      65 => 6,
+      75 => 7,
+      85 => 8,
+      95 => 9,
+      105 => 10,
+      115 => 11,
+      125 => 12,
+      135 => 13,
+      145 => 14,
+      155 => 15,
+      165 => 16,
+      175 => 17,
+      185 => 18,
+      195 => 19,
+      205 => 20,
+      215 => 21,
+      225 => 22,
+      235 => 23,
+      245 => 24,
+      255 => 25,
+      265 => 26,
+      275 => 27,
+      285 => 28,
+      295 => 29,
+      305 => 30,
+      315 => 31,
+  },
+}
+

data/lib/artbase/image/60x60.rb

@@ -0,0 +1,70 @@
+
+PIXEL_OFFSETS['60x60'] = {
+  '512x512' => {
+###########
+#   512x512 (60x60)
+#    assume 8px    60*8 = 480  + 32 = 512
+#
+#  e.g. 60.times {|i| puts "#{(4+i*8+32.0/60.0*i).to_i} => #{i}," }
+  4 => 0,
+  12 => 1,
+  21 => 2,
+  29 => 3,
+  38 => 4,
+  46 => 5,
+  55 => 6,
+  63 => 7,
+  72 => 8,
+  80 => 9,
+  89 => 10,
+  97 => 11,
+  106 => 12,
+  114 => 13,
+  123 => 14,
+  132 => 15,
+  140 => 16,
+  149 => 17,
+  157 => 18,
+  166 => 19,
+  174 => 20,
+  183 => 21,
+  191 => 22,
+  200 => 23,
+  208 => 24,
+  217 => 25,
+  225 => 26,
+  234 => 27,
+  242 => 28,
+  251 => 29,
+  260 => 30,
+  268 => 31,
+  277 => 32,
+  285 => 33,
+  294 => 34,
+  302 => 35,
+  311 => 36,
+  319 => 37,
+  328 => 38,
+  336 => 39,
+  345 => 40,
+  353 => 41,
+  362 => 42,
+  370 => 43,
+  379 => 44,
+  388 => 45,
+  396 => 46,
+  405 => 47,
+  413 => 48,
+  422 => 49,
+  430 => 50,
+  439 => 51,
+  447 => 52,
+  456 => 53,
+  464 => 54,
+  473 => 55,
+  481 => 56,
+  490 => 57,
+  498 => 58,
+  507 => 59,
+},
+}

data/lib/artbase/image/80x80.rb

@@ -0,0 +1,90 @@
+
+PIXEL_OFFSETS['80x80'] = {
+  '512x512' => {
+###########
+#   512x512 (80x80)
+#    assume 6px    80*6 = 480  + 32 = 512
+#
+#  e.g. 80.times {|i| puts "#{(3+i*6+32.0/80.0*i).to_i} => #{i}," }
+  3 => 0,
+  9 => 1,
+  15 => 2,
+  22 => 3,
+  28 => 4,
+  35 => 5,
+  41 => 6,
+  47 => 7,
+  54 => 8,
+  60 => 9,
+  67 => 10,
+  73 => 11,
+  79 => 12,
+  86 => 13,
+  92 => 14,
+  99 => 15,
+  105 => 16,
+  111 => 17,
+  118 => 18,
+  124 => 19,
+  131 => 20,
+  137 => 21,
+  143 => 22,
+  150 => 23,
+  156 => 24,
+  163 => 25,
+  169 => 26,
+  175 => 27,
+  182 => 28,
+  188 => 29,
+  195 => 30,
+  201 => 31,
+  207 => 32,
+  214 => 33,
+  220 => 34,
+  227 => 35,
+  233 => 36,
+  239 => 37,
+  246 => 38,
+  252 => 39,
+  259 => 40,
+  265 => 41,
+  271 => 42,
+  278 => 43,
+  284 => 44,
+  291 => 45,
+  297 => 46,
+  303 => 47,
+  310 => 48,
+  316 => 49,
+  323 => 50,
+  329 => 51,
+  335 => 52,
+  342 => 53,
+  348 => 54,
+  355 => 55,
+  361 => 56,
+  367 => 57,
+  374 => 58,
+  380 => 59,
+  387 => 60,
+  393 => 61,
+  399 => 62,
+  406 => 63,
+  412 => 64,
+  419 => 65,
+  425 => 66,
+  431 => 67,
+  438 => 68,
+  444 => 69,
+  451 => 70,
+  457 => 71,
+  463 => 72,
+  470 => 73,
+  476 => 74,
+  483 => 75,
+  489 => 76,
+  495 => 77,
+  502 => 78,
+  508 => 79,
+}
+}

data/lib/artbase/image.rb

@@ -0,0 +1,75 @@
+######################
+#  pixelart image extensions
+#    move upstream!!!!!
+
+
+module Pixelart
+
+class Image
+  def sample( *args, **kwargs )
+    ## note: for now always assume square image (e.g. 24x24, 32x32 and such)
+
+    offsets = if kwargs[:from] && kwargs[:to]
+                PIXEL_OFFSETS[ kwargs[:to] ][ kwargs[ :from ]]
+              else
+                args[0]   ## assume "custom" hash of offsets
+              end
+
+    width = height = offsets.size
+
+    puts "     #{self.width}x#{self.height} => #{width}x#{height}"
+
+
+    dest = Image.new( width, height )
+
+    offsets.each do |offset_x, x|
+      offsets.each do |offset_y, y|
+         pixel = self[offset_x,offset_y]
+
+         dest[x,y] =  pixel
+      end
+    end
+
+    dest
+  end
+  alias_method :pixelate, :sample
+end  # class Image
+
+
+
+class ImageComposite
+  def add_glob( glob )
+    files = Dir.glob( glob )
+    puts "#{files.size} file(s) found matching >#{glob}<"
+
+
+    files = files.sort
+    ## puts files.inspect
+
+    files.each_with_index do |file,i|
+      puts "==> [#{i+1}/#{files.size}] - #{file}"
+      img = Image.read( file )
+
+      self << img    ## todo/check: use add alias - why? why not?
+    end
+  end
+end   # class ImageComposite
+end   # module Pixelart
+
+
+###
+#   add common
+#     pixel(ate) offsets (for sampling)
+PIXEL_OFFSETS = {}
+
+module Pixelart
+  class Image
+    PIXEL_OFFSETS = ::PIXEL_OFFSETS
+  end
+end   # module Pixelart
+
+
+require_relative 'image/24x24'
+require_relative 'image/32x32'
+require_relative 'image/60x60'
+require_relative 'image/80x80'

data/lib/artbase/opensea.rb

@@ -0,0 +1,144 @@
+
+module OpenSea
+
+#############
+# read meta data into struct
+
+class Meta
+  def self.read( path )
+    txt  = File.open( path, 'r:utf-8' ) { |f| f.read }
+    data = JSON.parse( txt )
+    new( data )
+  end
+
+
+  def initialize( data )
+    @data = data
+
+    assets = @data['assets']
+    if assets.size != 1
+      puts "!! error - expected one asset per file only - got #{assets.size} - sorry"
+      exit 1
+    end
+
+    @asset = assets[0]
+  end
+
+  def name
+    @name ||= _normalize( @asset['name'] )
+  end
+
+  def description
+    @description ||= _normalize( @asset['description'] )
+  end
+
+  ## note: auto-convert "" (empty string) to nil
+  def image_original_url() _blank( @asset['image_original_url'] );  end
+  def image_url()          _blank( @asset['image_url'] ); end
+
+
+  def token_id() @asset['token_id']; end    ## note: keep id as string as is - why? why not?
+
+
+  def traits
+    @traits ||= begin
+                   traits = []
+                   ## keep traits as (simple)
+                   ##   ordered array of pairs for now
+                   ##
+                   ##  in a step two make lookup via hash table
+                   ##   or such easier / "automagic"
+
+                   @asset[ 'traits' ].each do |t|
+                      trait_type  = t['trait_type'].strip
+                      trait_value = t['value'].strip
+                      traits << [trait_type, trait_value]
+                   end
+
+                   traits
+                  end
+  end
+
+
+
+### "private"  convenience / helper methods
+    def _normalize( str )
+       return if str.nil?    ## check: check for nil - why? why not?
+
+       ## normalize string
+       ##   remove leading and trailing spaces
+       ##   collapse two and more spaces into one
+       ##    change unicode space to ascii
+       str = str.gsub( "\u{00a0}", ' ' )
+       str = str.strip.gsub( /[ ]{2,}/, ' ' )
+       str
+    end
+
+    def _blank( o )   ## auto-convert  "" (empty string) into nil
+       if o && o.strip.empty?
+         nil
+       else
+         o
+       end
+    end
+end  # class Meta
+
+
+
+BASE = 'https://api.opensea.io/api/v1/assets?collection={collection}&order_direction=asc&offset={offset}&limit=1'
+
+## todo/check: rename to query or search or such - why? why not?
+##
+##   add self.collect( collection, offset: 0 ) helper or such - why? why not?
+def self.assets( collection:, offset: 0 )
+  src = BASE.sub( '{collection}', collection ).
+             sub( '{offset}',     offset.to_s )
+
+  call( src )
+end
+
+
+def self.call( src )   ## get response as (parsed) json (hash table)
+  uri = URI.parse( src )
+
+  http = Net::HTTP.new( uri.host, uri.port )
+
+  puts "[debug] GET #{uri.request_uri} uri=#{uri}"
+
+  headers = {
+    'User-Agent' => "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36",
+    #'User-Agent' => "ruby v#{RUBY_VERSION}",
+   }
+
+
+  request = Net::HTTP::Get.new( uri.request_uri, headers )
+  if uri.instance_of? URI::HTTPS
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  end
+
+  response   = http.request( request )
+
+  if response.code == '200'
+    puts "#{response.code} #{response.message} -  content_type: #{response.content_type}, content_length: #{response.content_length}"
+
+    text = response.body.to_s
+    text = text.force_encoding( Encoding::UTF_8 )
+
+    data = JSON.parse( text )
+    data
+  else
+    puts "!! ERROR:"
+    puts "#{response.code} #{response.message}"
+    exit 1
+  end
+end
+end # module OpenSea
+
+
+
+
+#####
+# add convenience alias
+Opensea = OpenSea
+

data/lib/artbase/tool.rb

@@ -0,0 +1,159 @@
+
+
+
+module Artbase
+class Tool
+
+  def self.collection=(value)
+    puts "  setting collection to:"
+    pp value
+
+    @collection = value
+  end
+
+
+  def self.main( args=ARGV )
+    puts "==> welcome to collection tool with args:"
+    pp args
+
+    options = { }
+    parser = OptionParser.new do |opts|
+
+      opts.on("--offset NUM", Integer,
+              "Start counting at offset (default: 0)") do |num|
+          options[ :offset]  = num
+      end
+
+      opts.on("--limit NUM", Integer,
+              "Limit collection (default: ∞)") do |num|
+          options[ :limit]  = num
+      end
+
+      ## todo/fix: unsupported argument type: Range
+      ## opts.on("--range RANGE", Range,
+      ##        "Range of collection (default: 0..∞") do |range|
+      ##    options[ :range]  = range
+      ## end
+
+      opts.on("-h", "--help", "Prints this help") do
+        puts opts
+        exit
+      end
+    end
+
+    parser.parse!( args )
+    puts "options:"
+    pp options
+
+    puts "args:"
+    pp args
+
+    if args.size < 2
+      puts "!! ERROR - no command found - use <collection> <command>..."
+      puts ""
+      exit
+    end
+
+    name       = args[0]   ## todo/check - use collection_name/slug or such?
+    command    = args[1]
+    subcommand = args[2]
+
+
+    path = "./#{name}/config.rb"
+    puts "==> reading collection config >#{path}<..."
+
+    ## note: assume for now global const COLLECTION gets set/defined!!!
+    ##   use/change to a script/dsl loader/eval later!!!
+    load( path )
+
+    ## pp COLLECTION
+
+    ## configure collection  (note: requires self)
+    self.collection = COLLECTION
+
+
+    if ['d','dl','down', 'download'].include?( command )
+      if subcommand
+         if ['m', 'meta'].include?( subcommand )
+           download_meta
+         elsif ['i', 'img', 'image', 'images'].include?( subcommand )
+           download_images
+         end
+      else
+        download_meta
+        download_images
+      end
+    elsif ['p', 'px', 'pix', 'pixel', 'pixelate'].include?( command )
+      pixelate( offset: options[ :offset] )
+    elsif ['m', 'meta'].include?( command )
+      download_meta
+    elsif ['i', 'img', 'image', 'images'].include?( command )
+      download_images( offset: options[ :offset] )
+    elsif ['a', 'attr', 'attributes'].include?( command )
+      dump_attributes
+    elsif ['x', 'exp', 'export'].include?( command )
+      export_attributes
+    elsif ['c', 'composite'].include?( command )
+      make_composite
+    elsif ['t', 'test'].include?( command )
+       puts "  testing, testing, testing"
+    else
+      puts "!! ERROR - unknown command >#{command}<, sorry"
+    end
+
+    puts "bye"
+  end
+
+  def self.make_composite
+    puts "==> make composite"
+    @collection.make_composite
+  end
+
+  def self.dump_attributes
+    puts "==> dump attributes"
+    @collection.dump_attributes
+  end
+
+  def self.export_attributes
+    puts "==> export attributes"
+    @collection.export_attributes
+  end
+
+
+  def self.download_meta
+      puts "==> download meta"
+      @collection.download_meta
+  end
+
+  def self.download_images( offset: )
+     puts "==> download images"
+
+    ## note: use three dots (...) to exclude e.g. count 100 => 0 to 99)
+    range = if offset
+               (offset...@collection.count)
+            else
+               (0...@collection.count)
+            end
+
+     @collection.download_images( range )
+  end
+
+  def self.pixelate( offset: )
+    puts "==> pixelate"
+
+    ## note: use three dots (...) to exclude e.g. count 100 => 0 to 99)
+    range = if offset
+               (offset...@collection.count)
+            else
+               (0...@collection.count)
+            end
+
+    @collection.pixelate( range )
+  end
+end # class Tool
+
+
+end # module Artbase
+
+
+

data/lib/artbase/version.rb

@@ -1,10 +1,10 @@
 
 
-class Artbase
+module Artbase
 
   MAJOR = 0
-  MINOR = 0
-  PATCH = 1
+  MINOR = 1
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/artbase.rb

@@ -1,9 +1,42 @@
 require 'pp'
+require 'time'
+require 'date'
+
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'cgi'
+require 'fileutils'
+
+require 'json'
+
+require 'optparse'
+
+
+
+## our own gems
+require 'pixelart'
+
+
+
 
 
 ## our own code
 require 'artbase/version'    # note: let version always go first
 
+require 'artbase/image'
+
+
+require 'artbase/helper'
+require 'artbase/opensea'
+
+require 'artbase/collection'
+require 'artbase/attributes'
+
+
+require 'artbase/tool'
+
+
 
-pp Artbase.banner
-pp Artbase.root
+puts Artbase.banner
+puts Artbase.root