ordlite 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 238e3e5f3913821c8f0a70bdedb444deeea65da4ecdb5827f239b3b4a682a151
-  data.tar.gz: d01946f571d34b1b29ca7fe0216898f31fddc75e818d07300129af5d1a808c5e
+  metadata.gz: 6f1f6f768a785a0badc768db45c1c8ca831958f983b673fe48990846f3d4260e
+  data.tar.gz: 234d31cabdc7ed109144487792da9f77c39821f935e3d7d91a151b91e817d511
 SHA512:
-  metadata.gz: 1545c336ad9d22d92235bbe7160b3224a311cf5dd06b8a944d18d5d2e80c62a24f342be5ed3b295dd9b99cddd7654f931893f811a9571ef80688956cdff27178
-  data.tar.gz: 7300eb7a35ddcf56a41e10cdbc8844d81f8340147b18125d62a528d1eb27e4f8854e72ff70ec3858723ce2da99a3105b80f4414ec1706a593e81915b1aec9fb5
+  metadata.gz: 403e1addf0b974af179de293a26c5f1f47da8d0f665da1ca1a44a89cbcfb025a642a04930f49f6df35681527b2cbcaae855f87de4b7ce09e6cd88b4cffab1472
+  data.tar.gz: ab359d39d1dcdf307e8b3239ed61e2f10f8fc6bfc4316c3f9f5554a9fbc2d88b0d1c24f120afcab9b035c675d82d22e0292c6d1202db7219d64f5e8f2c214b54

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.1.2 / 2023-07-02
+### 0.2.1
 ### 0.0.1 / 2023-07-01
 
 * Everything is new. First release

data/Manifest.txt

@@ -5,8 +5,13 @@ Rakefile
 lib/ordlite.rb
 lib/ordlite/base.rb
 lib/ordlite/cache.rb
+lib/ordlite/factory.rb
+lib/ordlite/importer.rb
 lib/ordlite/models/blob.rb
+lib/ordlite/models/collection.rb
+lib/ordlite/models/factory.rb
 lib/ordlite/models/forward.rb
+lib/ordlite/models/generative.rb
 lib/ordlite/models/inscribe.rb
 lib/ordlite/schema.rb
 lib/ordlite/version.rb

data/README.md

@@ -4,8 +4,8 @@
 ordlite - ordinals inscription (on bitcoin & co) database let's you query via sql and more
 
 
-* home  :: [github.com/ordbase/generative-orc-721](https://github.com/ordbase/generative-orc-721)
-* bugs  :: [github.com/ordbase/generative-orc-721/issues](https://github.com/ordbase/generative-orc-721/issues)
+* home  :: [github.com/ordbase/ordbase](https://github.com/ordbase/ordbase)
+* bugs  :: [github.com/ordbase/ordbase/issues](https://github.com/ordbase/ordbase/issues)
 * gem   :: [rubygems.org/gems/ordlite](https://rubygems.org/gems/ordlite)
 * rdoc  :: [rubydoc.info/gems/ordlite](http://rubydoc.info/gems/ordlite)
 
@@ -13,7 +13,7 @@ ordlite - ordinals inscription (on bitcoin & co) database let's you query via sq
 
 ##  SQL Database Model
 
-Insribes •  Blobs
+Inscribes • Blobs • Collections • Factories • Generatives
 
 
 Table Inscribes
@@ -62,97 +62,165 @@ OrdDb.create_all     # build table schema
 puts
 puts "  #{Inscribe.count} inscribe(s)"
 puts "  #{Blob.count} blob(s)"
+puts "  #{Collection.count} collection(s)"
+puts "  #{Factory.count} factories"
+puts "  #{Generative.count} generative(s)"
 
 #=>  0 inscribe(s)
 #=>  0 blob(s)
+#=>  0 collection(s)
+#=>  0 generative(s)
 ```
 
 
 
 
-### Example No 1 - Query Ordgen Deploy / Mint Inscriptions
+### Example No 1 - Auto-Add (Via Ordinals.com) First Thousand Inscriptions (Sub 1k)
 
 ``` ruby
 require 'ordlite'
 
 
-OrdDb.connect( adapter:  'sqlite3',
-               database: './ord.db' )
+OrdDb.open( './ord.db' )
 
 
-####################
-## query for deploy candidates
-##
-##  e.g. sql where clause like
-##     content LIKE '%deploy%' 
-##       AND (   content LIKE '%orc-721%' 
-##            OR content LIKE '%og%')
-## 
+1000.times do |num|   # auto-add inscription 0-999
+   OrdDb.import( num )
+end
 
-deploys = Inscribe.deploys
-puts "   #{deploys.size} deploy candidate(s)"
+puts
+puts "  #{Inscribe.count} inscribe(s)"
+puts "  #{Blob.count} blob(s)"
+#=>   1000 inscribe(s)
+#=>   1000 blob(s)
+```
 
-deploys.each_with_index do |rec,i|
-    puts "==> deploy #{i} - num #{rec.num} - #{rec.bytes} bytes - #{rec.date}"
-    puts rec.content 
+Let's query for the ten biggest (by bytes) inscriptions 
+(and pretty print the result):
+
+```ruby
+Inscribe.biggest.limit(10).each do |rec|
+    print "#{number_to_human_size(rec.bytes)} (#{rec.bytes} bytes) - "
+    print "Inscribe №#{rec.num} (#{rec.content_type}) - "
+    print "#{rec.date} - #{rec.fee} fee in sats"
+    print "\n"
 end
+```
 
+resulting in:
 
-punks_deploys = Inscribe.deploys_by( slug: 'diypunks')
-puts "   #{punks_deploys.size} deploy candidate(s)"
+```
+3.73 MB (3915537 bytes) - Inscribe №652 (image/jpeg) - 2023-02-01 20:38:33 - 0 fee in sats
+385 KB (394718 bytes) - Inscribe №978 (application/epub+zip) - 2023-02-02 06:46:04 - 109325 fee in sats
+385 KB (394479 bytes) - Inscribe №546 (image/gif) - 2023-02-01 10:41:50 - 1489860 fee in sats
+385 KB (394440 bytes) - Inscribe №833 (image/png) - 2023-02-02 01:13:51 - 99314 fee in sats
+381 KB (389858 bytes) - Inscribe №388 (image/jpeg) - 2023-01-31 14:01:38 - 981620 fee in sats
+379 KB (388417 bytes) - Inscribe №291 (image/gif) - 2023-01-30 17:58:54 - 586794 fee in sats
+378 KB (386858 bytes) - Inscribe №857 (image/png) - 2023-02-02 01:17:54 - 97407 fee in sats
+374 KB (383322 bytes) - Inscribe №538 (image/jpeg) - 2023-02-01 10:20:28 - 96519 fee in sats
+367 KB (375414 bytes) - Inscribe №378 (image/gif) - 2023-01-31 09:47:55 - 945300 fee in sats
+365 KB (373504 bytes) - Inscribe №288 (image/jpeg) - 2023-01-30 16:51:46 - 94050 fee in sats
+```
 
 
+Let's query for all inscriptions grouped by date (day) and dump the results:
 
-#######################
-## query for mint candidates
-##
-##  e.g. sql where clause like
-##     content LIKE '%mint%' 
-##       AND (   content LIKE '%orc-721%' 
-##            OR content LIKE '%og%')
+```ruby
+pp Inscribe.counts_by_date   ## or count_by_day
+```
 
-mints = Inscribe.mints
-puts "   #{mints.size} mint candidate(s)"
+resulting in:
 
-## print last hundred mint candidates
-mints[-100,100].each_with_index do |rec,i|
-    puts "==> mint #{i} - num #{rec.num} - #{rec.bytes} bytes - #{rec.date}"
-    puts rec.content 
-end
+```
+{"2022-12-14" => 1,
+ "2022-12-17" => 1,
+ "2022-12-19" => 1,
+ "2023-01-05" => 1,
+ "2023-01-10" => 1,
+ "2023-01-12" => 1,
+ "2023-01-13" => 2,
+ "2023-01-15" => 1,
+ "2023-01-16" => 1,
+ "2023-01-19" => 5,
+ "2023-01-20" => 3,
+ "2023-01-21" => 5,
+ "2023-01-22" => 34,
+ "2023-01-23" => 23,
+ "2023-01-24" => 4,
+ "2023-01-25" => 9,
+ "2023-01-26" => 12,
+ "2023-01-27" => 19,
+ "2023-01-28" => 16,
+ "2023-01-29" => 128,
+ "2023-01-30" => 82,
+ "2023-01-31" => 98,
+ "2023-02-01" => 220,
+ "2023-02-02" => 332}
+```
 
+Let's query for all inscriptions grouped by month and dump the results:
 
-phunks_mints = Inscribe.mints_by( slug: 'diyphunks')
-puts "   #{phunks_mints.size} mint candidate(s)"
+```ruby
+pp Inscribe.counts_by_month
+```
 
+resulting in:
+
+```
+{"2022-12" => 3, 
+ "2023-01" => 445, 
+ "2023-02" => 552}
+```
+
+
+Let's query for all content types and group by count (descending) and dump the results:
 
-puts "   #{deploys.size} deploy candidate(s)"
-puts "   #{mints.size} mint candidate(s)"
 
-#=> 123 deploy candidate(s)
-#=> 7453 mint candidate(s)
+```ruby
+pp Inscribe.counts_by_content_type
+```
+
+resulting in:
+
+```
+{"image/png" => 475,
+ "image/jpeg" => 188,
+ "image/webp" => 117,
+ "text/plain;charset=utf-8" => 112,
+ "image/svg+xml" => 62,
+ "text/html;charset=utf-8" => 18,
+ "image/gif" => 11,
+ "audio/mpeg" => 6,
+ "application/pdf" => 2,
+ "image/avif" => 2,
+ "video/webm" => 2,
+ "application/epub+zip" => 1,
+ "application/pgp-signature" => 1,
+ "audio/midi" => 1,
+ "audio/mod" => 1,
+ "video/mp4" => 1}
 ```
 
+and so on.
 
 
 
-### Bonus:  Import (Cached) Inscription Datafiles (& Content)
+
+### Bonus:  Import (Cached) Inscription Meta Datafiles (& Content Blobs)
 
 Let's import all cached 
-inscriptions metadata datafiles (& content)
-from  [/ordinals.cache](https://github.com/ordbase/ordinals.cache)   
+inscriptions metadata datafiles (& content blobs)
+from  [/ordinals.cache](https://github.com/ordbase/ordinals.cache)
 into an (sql) database e.g. `ord.db`: 
 
 
 ``` ruby
 require 'ordlite'
 
-OrdDb.connect( adapter:  'sqlite3',
-               database: './ord.db' )
-
-OrdDb.create_all     # build table schema
+OrdDb.open( './ord.db' )
 
-cache_dir = './ordinals.cache/btc'
-cache =  OrdDb::Cache.new( cache_dir )
+cache_dir = './ordinals.cache/inscription'
+cache = Ordinals::Cache.new( cache_dir )
 cache.import_all
 
 
@@ -171,9 +239,12 @@ The scripts are dedicated to the public domain.
 Use it as you please with no restrictions whatsoever.
 
 
+## Questions? Comments?
+
+Join us in the [Ordgen / ORC-721 discord (chat server)](https://discord.gg/dDhvHKjm2t). Yes you can.
+Your questions and commetary welcome.
+
+
+Or post them over at the [Help & Support](https://github.com/geraldb/help) page. Thanks.
 
-Please post in the #generative-orc-721 channel
-in the ordinal punks discord.
-For an invite
-see <https://twitter.com/OrdinalPunks/status/1620230583711576068>.
 

data/Rakefile

@@ -9,7 +9,7 @@ Hoe.spec 'ordlite' do
   self.summary = "ordlite - ordinals inscription (on bitcoin & co) database let's you query via sql and more"
   self.description = summary
 
-  self.urls    = { home: 'https://github.com/ordbase/generative-orc-721' }
+  self.urls    = { home: 'https://github.com/ordbase/ordbase' }
 
   self.author  = 'Gerald Bauer'
   self.email   = 'gerald.bauer@gmail.com'
@@ -19,6 +19,7 @@ Hoe.spec 'ordlite' do
   self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
+    ['ordinals'],
     ['activerecord'],
     ['activerecord-utils'],
     ['logutils'],
@@ -26,6 +27,7 @@ Hoe.spec 'ordlite' do
     ['props'],
     ['props-activerecord'],
     ['sqlite3'],
+    ['pixelart'],   ## required for factory (ordgen/orc-721) support for now
   ]
 
   self.licenses = ['Public Domain']

data/lib/ordlite/base.rb

@@ -1,10 +1,6 @@
 # core and stlibs
+require 'ordinals'  ## will pull-in cocos & friends
 
-require 'pp'
-require 'fileutils'
-require 'uri'
-require 'json'
-require 'yaml'
 
 require 'logger'    # Note: use for ActiveRecord::Base.logger -- remove/replace later w/ LogUtils::Logger ???
 
@@ -31,6 +27,9 @@ require_relative 'models/forward'
 
 require_relative 'models/inscribe'
 require_relative 'models/blob'
+require_relative 'models/collection'
+require_relative 'models/factory'
+require_relative 'models/generative'
 
 
 require_relative 'schema'      
@@ -38,6 +37,10 @@ require_relative 'schema'
 require_relative 'cache'
 
 
+require_relative 'importer'  ## note: require (soft dep) ordinals gems!!!
+
+
+
 
 module OrdDb
 
@@ -53,6 +56,35 @@ module OrdDb
     OrdDb.create
   end
 
+  def self.auto_migrate!
+    ### todo/fix:
+    ##    check props table and versions!!!!!
+
+    # first time? - auto-run db migratation, that is, create db tables
+    unless LogDb::Model::Log.table_exists?
+      LogDb.create     # add logs table
+    end
+
+    unless ConfDb::Model::Prop.table_exists?
+      ConfDb.create    # add props table
+    end
+
+    unless OrdDb::Model::Inscribe.table_exists?
+      OrdDb.create
+    end
+  end # method auto_migrate!
+
+
+  def self.open( database='./ord.db' )   ## convenience helper for sqlite only
+      connect( adapter:  'sqlite3',
+               database: database )
+
+      ## build schema if database new/empty
+      auto_migrate!
+  end
+
+
+
   def self.connect( config={} )
 
     if config.empty?
@@ -102,5 +134,13 @@ module OrdDb
 end  # module OrdDb
 
 
+
+####
+# add factory (ordgen/orc-721) support here for now - why? why not?
+require 'pixelart'
+require_relative 'factory'
+
+
+
 # say hello
 puts Ordlite.banner     ## if defined?($RUBYCOCOS_DEBUG) && $RUBCOCOS_DEBUG

data/lib/ordlite/cache.rb

@@ -1,123 +1,64 @@
+###
+## add (database) import machinery to cache
 
-module OrdDb
-
-
-class  Cache   
-
-   Inscribe = Model::Inscribe
-   Blob     = Model::Blob
-
-def initialize( dir='.' )
-    @dir = dir
-end
-
-
-
-def import_all   
-   paths = Dir.glob( "#{@dir}/**.json" )
-   puts "  #{paths.size} inscribe datafile(s) found"
+module Ordinals
+class Cache
+   Inscribe = OrdDb::Model::Inscribe
+   Blob     = OrdDb::Model::Blob
 
+def import_all  
+   paths = _find_meta
+   puts "  #{paths.size} inscribe metaddatafile(s) found"
    paths.each_with_index do |path, i|
-     puts "==> inscribe #{i+1}/#{paths.size}..."
+     ## puts "==> inscribe #{i+1}/#{paths.size}..."
      data = _read_inscribe( path )
-     
-     Inscribe.create( _parse_inscribe( data ))
+     id = data['id']
+
+     ## skip if exists (use update later - why? why not?)
+     rec = Inscribe.find_by( id: id )
+     if rec 
+      ## skip - already in db
+        print '.'
+     else
+        print " #{id}"  #  NEW - add / insert into db"
+        rec = Inscribe.create_from_cache( data )
+     end
    end
+   puts
 
 
-   paths = Dir.glob( "#{@dir}/content/**.txt" )
-   puts "  #{paths.size} content datafile(s) found"
-
+   paths = _find_blobs
+   puts "  #{paths.size} inscribe blob(s) found"
    paths.each_with_index do |path, i|
-      puts "==> blob #{i+1}/#{paths.size}..."
-      content = _read_blob( path )
-      id      = File.basename( path, File.extname( path ))
-      
-      Blob.create( id: id,
-                   content: content )
+     ## puts "==> blob #{i+1}/#{paths.size}..."
+     content = read_blob( path )
+     id      = File.basename( File.dirname(path)) + 
+               File.basename( path, File.extname( path ))
+ 
+      rec = Blob.find_by( id: id )
+      if rec
+        ## skip - already in db
+        print '.'
+      else
+         print " #{id}"   # NEW - add / insert into db"
+         rec = Blob.create( id: id,
+                           content: content )
+      end
     end
+    puts
 end
 
-
 def import( id )
-   data = read( id )  
-   rec = Inscribe.create( _parse_inscribe( data ))
-   rec
-end
-
-def read( id )
-   _read_inscribe( "#{@dir}/#{id}.json" ) 
-end
-
-def _read_inscribe( path )
-   JSON.parse( _read_text( path )) 
-end
-
-def _read_blob( path )
-   blob = File.open( path, 'rb' ) { |f| f.read } 
-   ## auto force to ASCII-7BIT if not already - why? why not?
-   blob
-end
-
-
-def _read_text( path )
-   File.open( path, 'r:utf-8' ){ |f| f.read } 
-end
-
-def _parse_inscribe( data )
-   ## num via title
-   attributes = {
-    id:  data['id'],
-    num: _title_to_num( data['title'] ),
-    bytes: _content_length_to_bytes( data['content length'] ), 
-    sat:  data['sat'].to_i(10),
-    content_type:  data['content type'],
-    block: data['genesis height'].to_i(10),
-    fee: data['genesis fee'].to_i(10),
-    tx: data['genesis transaction'],
-    address: data['address'],
-    output: data['output'],
-    value: data['output value'].to_i(10),
-    offset: data['offset'].to_i(10),
-    # "2023-06-01 05:00:57 UTC"
-    date:  DateTime.strptime( data['timestamp'], 
-                              '%Y-%m-%d %H:%M:%S %z')
-  }
-
-  attributes
-end
-
-
-
-    ##  "title": "Inscription 9992615",
-TITLE_RX = /^Inscription (?<num>[0-9]+)$/i
-
-def _title_to_num( str )
-   if m=TITLE_RX.match( str )
-      m[:num].to_i(10)    ## use base 10
+   data = read( id )
+   rec = Inscribe.find_by( id: id )
+   if rec 
+      # skip - already in db
    else
-     puts "!! ERROR - no inscribe num found in title >#{str}<"
-     exit 1   ## not found - raise exception - why? why not?
+      rec = Inscribe.create_from_cache( data )
    end
 end
 
-CONTENT_LENGTH_RX = /^(?<num>[0-9]+) bytes$/i
-
-def _content_length_to_bytes( str )
-    if m=CONTENT_LENGTH_RX.match( str )
-       m[:num].to_i(10)    ## use base 10
-    else
-       puts "!! ERROR - bytes found in content lenght >#{str}<"
-       exit 1   ## not found - raise exception - why? why not?
-    end
-end
- 
-
-
-
-end # class Cache
-end # module OrdDb
-
-
 
+end  # class Cache
+end  # module Ordinals 
 

data/lib/ordlite/factory.rb

@@ -0,0 +1,132 @@
+
+
+class FactorySpritesheet    ## check - rename to catalog or atlas NOT spritesheet - why? why not?
+  def self.read_inscribes( *inscribes, width:, 
+                                       height: )
+     ## map inscribes to images                                  
+     images = inscribes.map {|inscribe| Pixelart::Image.blob( inscribe.content ) }
+     ## puts "  #{images.size} image(s)"
+
+     new( *images, width: width,
+                   height: height)                                
+  end
+
+  def initialize( *images, width:, 
+                           height: )
+     @tile_width  = width
+     @tile_height = height
+     @tiles = []
+     images.each {|img| add(img) }
+  end
+
+  def count() @tiles.size; end
+  alias_method :size,       :count 
+  alias_method :tile_count, :count   ## add tile_count - why? why not?
+  def tile_width() @tile_width; end     ## use width  - why? why not?
+  def tile_height() @tile_height; end   ## use height - why? why not?
+
+  def tile( index )  @tiles[ index ]; end
+  alias_method :[], :tile  
+
+  def add_inscribe( inscribe ) _add( Pixelart::Image.blob( inscribe.content )); end
+  def add( img )
+    ## 1:1 tile; use as is
+    if img.width == @tile_width && img.height == @tile_height
+        @tiles << img 
+    else  ## assume spritesheet??
+      ## wrap into composite image
+      composite = Pixelart::ImageComposite.new( img.image, width:  @tile_width,
+                                                           height: @tile_height )
+      cols  = img.width  / composite.tile_width
+      rows  = img.height / composite.tile_height                                           
+      puts "     #{composite.count} tile(s) in #{cols}x#{rows} grid"
+      composite.each {|tile| @tiles << tile }
+     end
+  end
+  alias_method :<<, :add
+end  ## class Spritesheet
+
+
+class FactoryGenerator
+  ###################
+  ## convenience setup helper(s)
+  def self.read_inscribes( *inscribes, width:, 
+                                       height: )                                         
+        new( FactorySpritesheet.read_inscribes( *inscribes,
+                                                   width: width,
+                                                   height: height ))
+  end
+ 
+  def initialize( spritesheet )
+    @spritesheet = spritesheet
+  end
+ 
+  def _parse( spec )
+    ## for delimiter allow for now:  - why? why not?
+    ##     (multiple) space ( )
+    ##      command or semicolon
+    spec.strip.split( %r{[ ,;/_-]+} ).map {|v| v.to_i(10) }
+  end
+ 
+  def parse( spec )
+    ## convenience helper
+    ##   parses g spec in various (delimited) formats
+    g = _parse( spec )
+    generate( *g )
+  end
+ 
+  def generate( *attributes )
+    img = Pixelart::Image.new( width, height )
+    attributes.each do |num|
+        img.compose!( @spritesheet[ num ] )
+    end
+    img
+  end
+  alias_method :g, :generate
+ 
+  def width()   @spritesheet.tile_width; end
+  def height()  @spritesheet.tile_height; end
+  def count()   @spritesheet.count; end
+end  # class FactoryGenerator
+ 
+
+
+module OrdDb
+module Model
+  
+class Factory
+
+## use id/slug to cache generators / spritesheets - why? why not?
+def self.generators
+    @generators ||= {}
+end
+
+def generator
+    generators = self.class.generators
+    if generators.has_key?( id )
+        generators[ id ]
+    else
+        ## auto-add generator on first-time/hit/demand
+        width, height = _parse_dimension( dim )
+        inscribes = layers.to_a  ## get layer inscribe records
+        generator = FactoryGenerator.read_inscribes( *inscribes,
+                                                     width: width,
+                                                     height: height )
+        generators[ id ] = generator
+        generator                         
+    end
+end
+
+def generate( *attributes )  ## add g shortcut alias - why? why not?
+    generator.generate( *attributes )
+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(10) }
+end
+
+end  # class Factory
+end  # module Model
+end  # module OrdDb