artbase 0.0.1 → 0.2.1

data/lib/artbase/collection/token.rb

@@ -0,0 +1,372 @@
+
+class TokenCollection   < Artbase::Base
+
+
+#############
+# (nested) Meta classes
+#    read meta data into struct
+class Meta
+  def self.read( path )
+    new( read_json( path ))
+  end
+
+
+  def initialize( data )
+    @data = data
+  end
+
+
+  def name
+    ## note: name might be an integer number e.g. 0/1/2 etc.
+    ##      e.g. see crypto pudgy punks and others?
+    ##    always auto-convert to string
+    @name ||= _normalize( @data['name'].to_s )
+  end
+
+
+  def description
+    @description ||= _normalize( @data['description'] )
+  end
+
+  ## note: auto-convert "" (empty string) to nil
+  def image()          _blank( @data['image'] ); end
+  alias_method :image_url, :image     ## add image_url alias - why? why not?
+
+
+  def attributes
+    @attributes ||= 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"
+
+                   @data[ 'attributes' ].each do |t|
+                      trait_type  = t['trait_type'].strip
+                      trait_value = t['value'].strip
+                      traits << [trait_type, trait_value]
+                   end
+
+                   traits
+                  end
+  end
+  alias_method :traits, :attributes    ## keep traits alias - why? why not?
+
+### "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  # (nested) class Meta
+
+
+
+
+  attr_reader :slug, :count
+
+  def initialize( slug, count,
+                  token_base:,
+                  image_base: nil,
+                  image_base_id_format: nil,
+                  format:,
+                  source:,
+                  top_x: 0,
+                  top_y: 0,
+                  center_x: true,
+                  center_y: true,
+                  excludes: [],
+                  offset: 0  )   # check: rename count to items or such - why? why not?
+    @slug = slug
+    @count = count
+    @offset = offset   ## starting by default at 0 (NOT 1 or such)
+
+    @token_base = token_base
+    @image_base = image_base
+    @image_base_id_format = image_base_id_format
+
+    @width, @height = _parse_dimension( format )
+
+
+    ## note: allow multiple source formats / dimensions
+    ### e.g. convert   512x512 into  [ [512,512] ]
+    ##
+    source = [source]  unless source.is_a?( Array )
+    @sources = source.map { |dimension| _parse_dimension( dimension ) }
+
+    @top_x = top_x    ## more (down)sampling / pixelate options
+    @top_y = top_y
+    @center_x = center_x
+    @center_y = center_y
+
+    @excludes = excludes
+  end
+
+
+  ## e.g. convert dimension (width x height) "24x24" or "24 x 24" to  [24,24]
+  def _parse_dimension( str )
+    str.split( /x/i ).map { |str| str.strip.to_i }
+  end
+
+
+  def _range( offset: 0 )    ## return "default" range  - make "private" helper public - why? why not?
+     ## note: range uses three dots (...) exclusive (NOT inclusive) range
+     ##  e.g. 0...100 => [0,..,99]
+     ##       1...101 => [1,..,100]
+     ##
+     ##  note: allow offset argument
+     ##           (to start with different offset - note: in addition to builtin 0/1 offset)
+
+     (0+@offset+offset...@count+@offset)
+  end
+
+
+
+def each_image( range=_range,
+                exclude: true,      &blk )
+  range.each do |id|
+    ####
+    # filter out/skip
+    # if exclude && @excludes.include?( id )
+    #  puts "  skipping / exclude #{id}..."
+    #  next
+    # end
+
+    puts "==> #{id}"
+    img = Image.read( "./#{@slug}/#{@width}x#{@height}/#{id}.png" )
+    blk.call( img, id )
+  end
+end
+
+
+def each_meta( range=_range,
+               exclude: true,      &blk )
+  range.each do |id|  ## check: change/rename id to index - why? why not?
+    meta = Meta.read( "./#{@slug}/token/#{id}.json" )
+
+    ####
+    # filter out/skip
+    # if exclude && @excludes.include?( meta.name )
+    #  puts "  skipping / exclude #{id} >#{meta.name}<..."
+    #  next
+    # end
+
+    blk.call( meta, id )
+  end
+end
+
+
+
+
+
+  def pixelate( range=_range, exclude: true,
+                              force: false,
+                              debug: false,
+                              zoom: nil )
+
+    range.each do |id|
+
+      if exclude && @excludes.include?( id )
+        puts "  skipping #{id}; listed in excludes #{@excludes.inspect}"
+        next
+      end
+
+      outpath = "./#{@slug}/#{@width}x#{@height}/#{id}.png"
+      if !force && File.exist?( outpath )
+        next   ## note: skip if file already exists
+      end
+
+      center_x =  if @center_x.is_a?( Proc ) then @center_x.call( id ); else @center_x; end
+      center_y =  if @center_y.is_a?( Proc ) then @center_y.call( id ); else @center_y; end
+
+
+
+      puts "==> #{id}  - reading / decoding #{id} ..."
+      start = Time.now
+
+      img = Image.read( "./#{@slug}/token-i/#{id}.png" )
+
+      stop = Time.now
+      diff = stop - start
+
+      puts "  in #{diff} sec(s)\n"
+
+
+      source = nil
+      @sources.each do |source_width, source_height|
+        if img.width == source_width && img.height == source_height
+            source = [source_width, source_height]
+            break
+        end
+      end
+
+
+      if source
+          source_width  = source[0]
+          source_height = source[1]
+
+          steps_x = Image.calc_sample_steps( source_width-@top_x, @width,   center: center_x )
+          steps_y = Image.calc_sample_steps( source_height-@top_y, @height, center: center_y )
+
+          pix = if debug
+                img.pixelate_debug( steps_x, steps_y,
+                                    top_x: @top_x,
+                                    top_y: @top_y )
+              else
+                img.pixelate( steps_x, steps_y,
+                              top_x: @top_x,
+                              top_y: @top_y )
+              end
+        ## todo/check: keep usingu slug e.g. 0001.png or "plain" 1.png - why? why not?
+        ## slug = "%04d" % id
+        pix.save( outpath )
+
+        if zoom
+          outpath = "./#{@slug}/#{@width}x#{@height}/#{id}@#{zoom}x.png"
+          pix.zoom( zoom ).save( outpath )
+        end
+      else
+        puts "!! ERROR - unknown/unsupported dimension - #{img.width}x#{img.height}; sorry - tried:"
+        pp @sources
+        exit 1
+      end
+    end
+  end
+
+
+
+  def meta_url( id: )
+    src = @token_base.gsub( '{id}', id.to_s )
+
+    ## quick ipfs (interplanetary file system) hack - make more reusabele!!!
+    src = handle_ipfs( src )
+    src
+  end
+  alias_method :token_url, :meta_url
+
+
+  def image_url( id:,
+                 direct: @image_base ? true : false  )
+    src =  if direct && @image_base
+              ###
+              ## todo/fix:
+              ##   change image_base_id_format
+              ##    to image_base proc with para id and call proc!!!!
+              if @image_base_id_format
+                @image_base.gsub( '{id}', @image_base_id_format % id )
+              else
+                @image_base.gsub( '{id}', id.to_s )
+              end
+           else
+              ## todo/check - change/rename data to meta - why? why not?
+              data = Meta.read( "./#{@slug}/token/#{id}.json" )
+
+              meta_name  = data.name
+              meta_image = data.image
+
+              puts "==> #{id} - #{@slug}..."
+              puts "   name: #{meta_name}"
+              puts "   image: #{meta_image}"
+              meta_image
+          end
+    src
+
+    ## quick ipfs (interplanetary file system) hack - make more reusabele!!!
+    src = handle_ipfs( src )
+    src
+ end
+
+
+
+  def download_meta( range=_range, force: false )
+    start = Time.now
+    delay_in_s = 0.3
+
+    range.each do |id|
+      outpath = "./#{@slug}/token/#{id}.json"
+      if !force && File.exist?( outpath )
+        next   ## note: skip if file already exists
+      end
+
+      dirname = File.dirname( outpath )
+      FileUtils.mkdir_p( dirname )  unless Dir.exist?( dirname )
+
+      puts "==> #{id} - #{@slug}..."
+
+      token_src = meta_url( id: id )
+      copy_json( token_src, outpath )
+
+      stop = Time.now
+      diff = stop - start
+      puts "    download token metadata in #{diff} sec(s)"
+
+      mins = diff / 60  ## todo - use floor or such?
+      secs = diff % 60
+      puts "up #{mins} mins #{secs} secs (total #{diff} secs)"
+
+      puts "sleeping #{delay_in_s}s..."
+      sleep( delay_in_s )
+    end
+  end
+
+
+  ## note: default to direct true if image_base present/availabe
+  ##                    otherwise to false
+  ##   todo/check: change/rename force para to overwrite - why? why not?
+  def download_images( range=_range, force: false,
+                                           direct: @image_base ? true : false )
+    start = Time.now
+    delay_in_s = 0.3
+
+    range.each do |id|
+
+      ## note: skip if (downloaded) file already exists
+      skip = false
+      if !force
+        ['png', 'gif', 'jgp', 'svg'].each do |format|
+          if File.exist?( "./#{@slug}/token-i/#{id}.#{format}" )
+            skip = true
+            break
+          end
+        end
+      end
+      next if skip
+
+      image_src = image_url( id: id, direct: direct )
+
+      ## note: will auto-add format file extension (e.g. .png, .jpg)
+      ##        depending on http content type!!!!!
+      start_copy = Time.now
+      copy_image( image_src, "./#{@slug}/token-i/#{id}" )
+
+      stop = Time.now
+
+      diff = stop - start_copy
+      puts "    download image in #{diff} sec(s)"
+
+      diff = stop - start
+      mins = diff / 60  ## todo - use floor or such?
+      secs = diff % 60
+      puts "up #{mins} mins #{secs} secs (total #{diff} secs)"
+
+      puts "sleeping #{delay_in_s}s..."
+      sleep( delay_in_s )
+    end
+  end
+
+end # class TokenCollection

data/lib/artbase/collection.rb

@@ -0,0 +1,12 @@
+
+
+
+
+
+
+
+require_relative 'collection/base'
+require_relative 'collection/token'
+require_relative 'collection/image'
+require_relative 'collection/opensea'
+

data/lib/artbase/helper.rb

@@ -0,0 +1,169 @@
+
+
+
+def slugify( name )
+  name.downcase.gsub( /[^a-z0-9 ()$_-]/ ) do |_|
+     puts " !! WARN: asciify - found (and removing) non-ascii char >#{Regexp.last_match}<"
+     ''  ## remove - use empty string
+  end.gsub( ' ', '_')
+end
+
+
+
+=begin
+  moved/ use Image.convert !!!  remove here
+def convert_images( collection, from: 'jpg',
+                                to: 'png',
+                                dir: 'i',
+                                overwrite: true )
+    files = Dir.glob( "./#{collection}/#{dir}/*.#{from}" )
+    puts "==> converting #{files.size} image(s) from #{from} to #{to}"
+
+    files.each_with_index do |file,i|
+      dirname   = File.dirname( file )
+      extname   = File.extname( file )
+      basename  = File.basename( file, extname )
+
+      ## skip convert if target / dest file already exists
+      next  if overwrite == false && File.exist?( "#{dirname}/#{basename}.#{to}" )
+
+
+      cmd = "magick convert #{dirname}/#{basename}.#{from} #{dirname}/#{basename}.#{to}"
+
+      puts "   [#{i+1}/#{files.size}] - #{cmd}"
+      system( cmd )
+
+      if from == 'gif'
+        ## assume multi-images for gif
+        ##   save  image-0.png  to  image.png
+        path0 = "#{dirname}/#{basename}-0.#{to}"
+        path  = "#{dirname}/#{basename}.#{to}"
+
+        puts "   saving #{path0} to #{path}..."
+
+        blob = File.open( path0, 'rb' ) { |f| f.read }
+        File.open( path, 'wb' ) { |f| f.write( blob ) }
+      end
+    end
+end
+=end
+
+
+
+
+
+
+
+def copy_json( src, dest )
+  uri = URI.parse( src )
+
+  http = Net::HTTP.new( uri.host, uri.port )
+
+  puts "[debug] GET #{uri.request_uri} uri=#{uri}"
+
+  headers = { '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}"
+    puts "  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 )
+
+    File.open( dest, "w:utf-8" ) do |f|
+      f.write( JSON.pretty_generate( data ) )
+    end
+  else
+    puts "!! error:"
+    puts "#{response.code} #{response.message}"
+    exit 1
+  end
+end
+
+
+def copy_image( src, dest,
+                 dump_headers: false )
+  uri = URI.parse( src )
+
+  http = Net::HTTP.new( uri.host, uri.port )
+
+  puts "[debug] GET #{uri.request_uri} uri=#{uri}"
+
+  headers = { '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
+    puts "  content_type: #{content_type}, content_length: #{content_length}"
+
+    if dump_headers   ## for debugging dump headers
+      headers = response.each_header.to_h
+      puts "htttp respone headers:"
+      pp headers
+    end
+
+
+    format = if content_type =~ %r{image/jpeg}i
+                'jpg'
+             elsif content_type =~ %r{image/png}i
+                'png'
+              elsif content_type =~ %r{image/gif}i
+                'gif'
+              elsif content_type =~ %r{image/svg}i
+                'svg'
+             else
+              puts "!! error:"
+              puts " unknown image format content type: >#{content_type}<"
+              exit 1
+            end
+
+    ##   make sure path exits - autocreate dirs
+    ## make sure path exists
+    dirname = File.dirname( "#{dest}.#{format}" )
+    FileUtils.mkdir_p( dirname )  unless Dir.exist?( dirname )
+
+    if format == 'svg'
+      ## save as text  (note: assume utf-8 encoding for now)
+      text = response.body.to_s
+      text = text.force_encoding( Encoding::UTF_8 )
+
+      File.open( "#{dest}.svg", 'w:utf-8' ) do |f|
+        f.write( text )
+      end
+    else
+      ## save as binary
+      File.open( "#{dest}.#{format}", 'wb' ) do |f|
+        f.write( response.body )
+      end
+    end
+  else
+    puts "!! error:"
+    puts "#{response.code} #{response.message}"
+    exit 1
+  end
+end
+
+
+
+

data/lib/artbase/image/sample.rb

@@ -0,0 +1,31 @@
+module Pixelart
+
+  class Image
+
+###
+#   add common
+#     pixel(ate) steps/offsets (for re/down/sampling)
+DOwNSAMPLING_STEPS = {
+  '24x24' => {
+    '269x269' => Image.calc_sample_steps( 269, 24 ),  # width (269px), new_width (24px)
+    '512x512' => Image.calc_sample_steps( 512, 24 ),  # width (512px), new_width (24px)
+  },
+  '32x32' => {
+    '320x320' => Image.calc_sample_steps( 320, 32 ),
+    '512x512' => Image.calc_sample_steps( 512, 32 ),
+  },
+  '35x35' => {
+    '512x512' => Image.calc_sample_steps( 512, 35 ),
+  },
+  '60x60' => {
+    '512x512' => Image.calc_sample_steps( 512, 60 ),
+  },
+  '80x80' => {
+    '512x512' => Image.calc_sample_steps( 512, 80 ),
+  },
+}
+
+  end  # class Image
+end   # module Pixelart
+
+

data/lib/artbase/image.rb

@@ -0,0 +1,31 @@
+######################
+#  pixelart image extensions
+#    move upstream!!!!!
+
+
+module Pixelart
+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
+
+
+
+require_relative 'image/sample'    ## check - change to downsample/pixelate - why? why not?
+
+
+

data/lib/artbase/retry.rb

@@ -0,0 +1,41 @@
+
+## for more ideas on retry
+##    see https://github.com/ooyala/retries
+
+
+## todo/check:  use a different name than retry - why? why not?
+def retry_on_error( max_tries: 3, &block )
+  errors = []
+  delay = 3  ## 3 secs
+
+    begin
+      block.call
+
+    ## note: add more exception here (separated by comma) like
+    ##         rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED => e
+    rescue Net::ReadTimeout => e
+        ##  (re)raise (use raise with arguments or such - why? why not?)
+        raise    if errors.size >= max_tries
+
+        ## ReadTimeout, a subclass of Timeout::Error, is raised if a chunk of the response cannot be read within the read_timeout.
+        ##                subclass of RuntimeError
+        ##                subclass of StandardError
+        ##                subclass of Exception
+        puts "!! ERROR - #{e}:"
+        pp e
+
+        errors << e
+
+        puts
+        puts "==> retrying (count=#{errors.size}, max_tries=#{max_tries}) in #{delay} sec(s)..."
+        sleep( delay )
+        retry
+    end
+
+  if errors.size > 0
+    puts "  #{errors.size} retry attempt(s) on error(s):"
+    pp errors
+  end
+
+  errors
+end