valkey-objects 0.4.8 → 0.5.0

data/lib/valkey/objects.rb

@@ -1,813 +1,576 @@
-# frozen_string_literal: true
+require 'redis'
 
-require_relative "objects/version"
-
-require 'connection_pool'
-require 'redis-client'
-require 'json'
-require 'amatch'
-require 'ap'
-require 'yaml'
-require 'classifier-reborn'
-require 'knn'
-require 'sentimental'
-require 'tokenizer'
+module ValkeyObjects
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def valkey
+      @valkey ||= Redis.new
+    end
+    
+    def valkey=(client)
+      @valkey = client
+    end
 
-module VK
+    def knn *a
+      KNN.new([a].flatten.compact)
+    end
 
+    # Define a value (string) attribute
+    def value(name, options = {})
+      key_name = options[:key] || name.to_s
 
-  @@XX = {}
-  
-  def self.included(x)
-    x.extend VK
-  end
-  
-  def self.extended(x)
-    ##
-    # Example:
-    # class ExmpleObject
-    #  include VK
-    #
-    ## Add Object Containers by Value Type:
-    #  value :myValue
-    #  counter :myCounter
-    #  hashkey :myHashKey
-    #  sortedset :mySortedSet
-    #  set :mySet
-    #  queue :myQueue
-    #  place :myPlace
-    #  toggle :myToggle
-    #  ticker :myTicker
-    #  entry :myEntry
-    #
-    ## Add an Object Container With an Implicit Expiration:
-    #  value :myExpiringValue, ttl: (seconds to live without interaction)
-    #
-    #  def initialize k
-    #   @id = k
-    #  end
-    # end
-    ##
-    # Create the Object:
-    # @obj = ExampleObject.new('object id...')
-    ##
-    # For all object methods:
-    # @obj.myObjectContainer.expire(seconds)
-    # @obj.myObjectContainer.delete!
-    # 
-    xx = x.name.gsub("::", "-")
-    ##
-    # Object Method Types: 
-    ##
-    # A String Value
-    ##
-    # value :myValue
-    # @obj.myValue
-    # @obj.myValue.exist?
-    # @obj.myValue.value = "my value"
-    # @obj.myValue.value => "my value"
-    define_method(:value) { |k, h={}| define_method(k.to_sym) { VALUE.new(%[#{xx}:value:#{k}:#{@id}], h) } };
-    ##
-    # A Number Value 
-    ##
-    # counter :myCounter
-    # @obj.myCounter
-    # @obj.myCounter.exist?
-    # @obj.myCounter.value = number
-    # @obj.myCounter.value => number
-    # @obj.myCounter.incr number                                                                                                                
-    # @obj.myCounter.decr number    
-    #
-    define_method(:counter) { |k, h={}| define_method(k.to_sym) { COUNTER.new(%[#{xx}:counter:#{k}:#{@id}], h); } };
-    ##
-    # An Epoch Value
-    ##
-    # timestamp :myTimestamp
-    # @obj.myTimestamp
-    # @obj.myTimestamp.exist?
-    # @obj.myTimestamp.value!
-    # @obj.myTimestamp.value => epoch
-    # @obj.myTimestamp.ago => Seconds since epoch
-    # @obj.myTimestamp.to_time => Time object
-    define_method(:timestamp) { |k, h={}| define_method(k.to_sym) { TIMESTAMP.new(%[#{xx}:timestamp:#{k}:#{@id}], h) } }
-    ##
-    # A Hash Value
-    ##
-    # hashkey :myHashKey
-    # @obj.myHashKey
-    # @obj.myHashKey[:key] = value
-    # @obj.myHashKey[:key] => "value"
-    # @obj.myHashKey.update({ key: 'value', ... })
-    define_method(:hashkey) { |k, h={}| define_method(k.to_sym) { HASH.new(%[#{xx}:hashkey:#{k}:#{@id}], h); } };
-    ##
-    # A Sorted Set Value
-    ##
-    # sortedset :mySortedSet
-    # @obj.mySortedSet
-    # @obj.mySortedSet[:key] = value                                                                                                                 
-    # @obj.mySortedSet[:key] => ...    
-    # @obj.mySortedSet.value { |key, i| ... }
-    # @obj.mySortedSet.poke key, number
-    #
-    define_method(:sortedset) { |k, h={}| define_method(k.to_sym) { SORTEDSET.new(%[#{xx}:sortedset:#{k}:#{@id}], h); } };
-    ##
-    # A Collection of Values
-    ##
-    # set :mySet
-    # @obj.mySet
-    # @obj.mySet << "x"
-    # @obj.myset.rm "x"
-    # @obj.mySet & @obj.otherSet
-    # @obj.mySet | @obj.otherSet
-    # @obj.myset["pattern"]
-    # @obj.mySet.value { |key, i| ... }    
-    #    
-    define_method(:set) { |k, h={}| define_method(k.to_sym) { SET.new(%[#{xx}:set:#{k}:#{@id}], h); } };
-    ##
-    # A List of Values
-    ##
-    # queue :myQueue
-    # @obj.myQueue
-    # @obj.myQueue << "x"
-    # @obj.myQueue.front => "x" and pop
-    # @obj.myQueue.last => last in queue
-    # @obj.myQueue.value { |key, i| ... }    
-    #
-    define_method(:queue) { |k, h={}| define_method(k.to_sym) { QUEUE.new(%[#{xx}:queue:#{k}:#{@id}], h); } };
-    ##
-    # A Collection of Places
-    ##
-    # place :myPlace
-    # @obj.myPlace
-    # @obj.myPlace.add "key", longitude, latitude
-    # @obj.myPlace["key"] => { longitude: xx, latitude: yy }
-    # @obj.myPlace.distance "key", "other key"
-    # @obj.myPlace.radius longitude, latitude, distance
-    # @obj.myPlace.value { |key, i| ... }
-    #
-    define_method(:place) { |k, h={}| define_method(k.to_sym) { PLACE.new(%[#{xx}:place:#{k}:#{@id}], h); } };
-    ##
-    # A Boolean Value
-    ##
-    # toggle :myToggle
-    # @obj.myToggle
-    # @obj.myToggle.exist?
-    # @obj.myToggle.value = bool
-    # @obj.myToggle.value => ...
-    # @obj.myToggle.value! => value = !value
-    #
-    define_method(:toggle) { |k, h={}| define_method(k.to_sym) { TOGGLE.new(%[#{xx}:toggle:#{k}:#{@id}], h); } };
-    ##
-    # A Sorted Hash of Values 
-    ##
-    # ticker :myTicker
-    # @obj.myTicker
-    # @obj.myTicker[:key] = value
-    # @obj.myTicker[:key] => "value"
-    # @obj.myticker.value { |i,e| ... }
-    define_method(:ticker) { |k, h={}| define_method(k.to_sym) { SORTEDHASH.new(%[#{xx}:ticker:#{k}:#{@id}], h); } };
-    ##
-    # A List of Hashes
-    ##
-    # entry :myEntry
-    # @obj.myEntry
-    # @obj.myEntry << { key: 'value', ... }
-    # @obj.myEntry.value { |i,e| ... }
-    define_method(:entry) { |k, h={}| define_method(k.to_sym) { HASHLIST.new(%[#{xx}:entry:#{k}:#{@id}], h); } };
-    ##
-    # A list of Strings
-    ##
-    # vector :myVector
-    # @obj.myVector
-    # @obj.myVector << "An Entry of Text."
-    # @obj.myVector.value { |i,e| ... }
-    # @obj.myvector[0] = "An Entry of Text."
-    define_method(:vector) { |k, h={}| define_method(k.to_sym) { VECTOR.new(%[#{xx}:vector:#{k}:#{@id}], h); } };
-    ##
-    # An ordered list of strings.
-    ##
-    # vector :myCorpus
-    # @obj.myCorpus
-    # @obj.myCorpus.value { |i,e| ... }
-    # @obj.myCorpus["An entry"] => 5
-    define_method(:corpus) { |k, h={}| define_method(k.to_sym) { CORPUS.new(%[#{xx}:corpus:#{k}:#{@id}], h); } }; 
-    ##
-    # An ordered list of strings.
-    ##
-    # book :myBook
-    # @obj.myBook
-    # @obj.myBook.value { |index,entry,embedding| ... }
-    # @obj.mybook.near("Some entry") => [...]
-    # @obj.myBook["An entry"] => 5
-    define_method(:book) { |k, h={}| define_method(k.to_sym) { BOOK.new(%[#{xx}:book:#{k}:#{@id}], h); } };    
-  end
-  
-  def id
-    @id
-  end
-  
-  def self.at epoch
-    Time.at epoch
-  end
-  
-  def self.clock *t
-    if t[0]
-      Time.now.utc.to_i - t[0].to_i
-    else
-      Time.now.utc.to_i
+      define_method(name) do
+        ValkeyObjects::Value.new("#{self.class.name.downcase}:#{@id}:value:#{key_name}", self.class.valkey)
+      end
     end
-  end
-  
-  def self.redis
-    @redis ||= ConnectionPool::Wrapper.new do
-      RedisClient.config(host: "127.0.0.1", port: 6379, db: 0).new_client
+    
+    # Define a counter attribute
+    def counter(name, options = {})
+      key_name = options[:key] || name.to_s
+
+      define_method(name) do
+        ValkeyObjects::Counter.new("#{self.class.name.downcase}:#{@id}:counter:#{key_name}", self.class.valkey)
+      end
     end
-  end
-  
-  @@SENTIMENT_THRESHOLD = 0.9
-  ##
-  # Bayesean Classification
-  #
-  # Determine the A OR B of an example.
-  ##
-  # VK.classify("catagory A", "Catagory B").
-  def self.classify(a, b)
-    ClassifierReborn::Bayes.new(a, b)
-  end
-  
-  def self.threshold n
-    @@SENTIMENT_THRESHOLD = n
-  end
-  ##
-  # Sentiment Analysis.
-  ##
-  # VK.feels("Some text")
-  def self.feels x
-    Sentimental.new(threshold: @@SENTIMENT_THRESHOLD).sentiment
-  end
-  
-  @@CRi = Hash.new { |h,k| h[k] = CRi.new(k) }
-  class CRi
-    def initialize k
-      @id = k
-      @lsi = ClassifierReborn::LSI.new
+    
+    # Define a list attribute
+    def list(name, options = {})
+      key_name = options[:key] || name.to_s
+      
+      define_method(name) do
+        ValkeyObjects::List.new("#{self.class.name.downcase}:#{@id}:list:#{key_name}", self.class.valkey)
+      end
     end
-    def learn x, i
-      @lsi.add_item x.to_s, i.to_sym
+    
+    # Define a set attribute
+    def set(name, options = {})
+      key_name = options[:key] || name.to_s
+      
+      define_method(name) do
+        ValkeyObjects::Set.new("#{self.class.name.downcase}:#{@id}:set:#{key_name}", self.class.valkey)
+      end
     end
-    def [] k
-      @lsi.classify k
+    
+    # Define a hash attribute
+    def hash_key(name, options = {})
+      key_name = options[:key] || name.to_s
+      
+      define_method(name) do
+        ValkeyObjects::HashKey.new("#{self.class.name.downcase}:#{@id}:hash:#{key_name}", self.class.valkey)
+      end
     end
-    def search x, *n
-      @lsi.search(x, n[0])
+    
+    # Define a sorted set attribute
+    def sorted_set(name, options = {})
+      key_name = options[:key] || name.to_s
+      
+      define_method(name) do
+        ValkeyObjects::SortedSet.new("#{self.class.name.downcase}:#{@id}:sorted_set:#{key_name}", self.class.valkey)
+      end
     end
   end
-  ##
-  # Vector Indexing
-  # 
-  # Vector (of text) -> concept (index)
-  # - Find text concept based upon known examples.
-  # - Learn new examples of a concept.
-  # - Find examples from within clusters.
-  ##
-  # index[:vector]['Text to classify'] => :index
-  # index[:vector].learn("Text to classify", :index)
-  # index[:vector].search("Similar text.", 5) => ["Similar text?", "other similar text", ...]
-  def self.index
-    @@CRi
-  end
-  ##
-  # Vector Engine
-  #
-  # Return known string based upon nearest neighbor by vector of number.
-  ##
-  # vector([["return val", 0, 1, 2, ...], ...]).classify(["guess", 0, 1, 2, ...]) => "return val"
-  def self.vector vectors, size
-    Knn::Classifier.new(vectors, SquaredEuclideanCalculator)
+
+  # generic KNN processor
+  class KNN
+    # Initialize with a collection of strings
+    def initialize(collection)
+      @collection = collection.flatten.compact
+    end
+    
+    # Find k nearest neighbors to the query string
+    # Returns array of hashes with :string and :distance keys
+    def hood(query)
+      # Calculate distances for all strings
+      distances = @collection.map do |str|
+        { string: str, distance: levenshtein_distance(query, str) }
+      end
+      
+      # Sort by distance (ascending) and take top k
+      distances.sort_by { |item| item[:distance] }.take([10, @collection.size].min)
+    end
+    
+    def rank query
+      neighbors = hood(query)
+      
+      neighbors.map do |item|
+        max_len = [query.length, item[:string].length].max
+        similarity = max_len.zero? ? 1.0 : 1.0 - (item[:distance].to_f / max_len)
+        dist = levenshtein_distance(item[:string], query)
+        { string: item[:string], similarity: similarity.round(4), distance: dist.round(4) }
+      end.sort_by { |h| h[:distance] && -h[:similarity] }
+    end
+    
+    def [] q
+      rank(q)[0][:string]
+    end
+    
+    private
+    
+    # Calculate Levenshtein distance between two strings
+    def levenshtein_distance(s1, s2)
+      return s2.length if s1.empty?
+      return s1.length if s2.empty?
+      
+      # Create distance matrix
+      d = Array.new(s1.length + 1) { Array.new(s2.length + 1) }
+      
+      # Initialize first row and column
+      (0..s1.length).each { |i| d[i][0] = i }
+      (0..s2.length).each { |j| d[0][j] = j }
+      
+      # Fill in the rest of the matrix
+      (1..s1.length).each do |i|
+        (1..s2.length).each do |j|
+          cost = s1[i - 1] == s2[j - 1] ? 0 : 1
+          
+          d[i][j] = [
+            d[i - 1][j] + 1,      # deletion
+            d[i][j - 1] + 1,      # insertion
+            d[i - 1][j - 1] + cost # substitution
+          ].min
+        end
+      end
+      
+      d[s1.length][s2.length]
+    end
   end
   
-  class O
-    attr_reader :key
-    def initialize k, h={}
-      @key = k
-      @opts = h
-#      puts %[VK #{@key} #{h}]
-      if @opts.has_key?(:ttl)
-        expire @opts[:ttl]
-      end
+  # Value (String) wrapper
+  class Value
+    attr_reader :key, :valkey
+    
+    def initialize(key, valkey)
+      @key = key
+      @valkey = valkey
+    end
+    
+    def value
+      valkey.get(key)
     end
-    def delete!
-      VK.redis.call("DEL", key);
+    
+    def value=(val)
+      valkey.set(key, val)
     end
-    def expire sec
-      VK.redis.call("EXPIRE", key, sec);
+    
+    def delete
+      valkey.del(key)
+    end
+    
+    def exists?
+      valkey.exists?(key)
     end
-    def value
-      x = VK.redis.call("GET", key);
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
-      return x
-    end    
-  end
 
-  class TIMESTAMP < O
-    def value!
-      VK.redis.call("SET", key, "#{VK.clock.to_i}");
+    def expire(seconds)
+      valkey.expire(key, seconds)
     end
-    def exist?
-      VK.redis.call("GET", key) ? true : false
+
+    def expireat(unix_timestamp)
+      valkey.expireat(key, unix_timestamp)
     end
-    def ago
-      VK.clock.to_i - value.to_i;
+
+    def ttl
+      valkey.ttl(key)
     end
-    def to_time
-      Time.at(value);
+
+    def persist
+      valkey.persist(key)
+    end
+    
+    def to_s
+      value.to_s
     end
   end
   
-  class TOGGLE < O
-    def value
-      x = VK.redis.call("GET", key) == 'true' ? true : false
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
-      return x
+  # Counter wrapper
+  class Counter
+    attr_reader :key, :valkey
+    
+    def initialize(key, valkey)
+      @key = key
+      @valkey = valkey
     end
-    def exist?                                                                                                                                        
-      VK.redis.call("GET", key) ? true : false                                                                                                        
-    end    
+
     def value= x
-       VK.redis.call("SET", key, "#{x.to_s}")
+      valkey.set(key, x)
     end
-    def value!
-      if self.value == true || self.value == nil
-        self.value = false
-      else
-        self.value = true
-      end
-    end
-  end
-  
-  class VALUE < O
+    
     def value
-      x = VK.redis.call("GET", key)
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
-      return x
+      val = valkey.get(key)
+      val ? val.to_i : 0
     end
-    def value= x
-      VK.redis.call("SET", key, x)
+    
+    def increment(by = 1)
+      valkey.incrby(key, by)
     end
-    def exist?                                                                                                                                        
-      VK.redis.call("GET", key) ? true : false                                                                                                        
+    
+    def decrement(by = 1)
+      valkey.decrby(key, by)
     end
-    def match r, &b
-      m = Regexp.new(r).match(value)
-      if block_given?
-        b.call(m)
-      else
-        return m
-      end
+    
+    def reset
+      valkey.set(key, 0)
+    end
+    
+    def delete
+      valkey.del(key)
     end
-  end
 
-  class VECTOR < O
-    include Amatch
-    def value &b
-      a = []
-      VK.redis.call("LRANGE", key, 0, -1).each_with_index { |e, i|                                                                                    
-        if block_given?
-          a << b.call(i, VK.redis.call("GET", e))
-        else
-          a << VK.redis.call("GET", e)
-        end
-        if @opts.has_key?(:flush) == true
-          VK.redis.call("DEL", e);
-        end
-      }
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
-      return a
-    end
-    def [] k
-      VK.redis.call("GET", "#{@key}-#{k}");
-    end
-    def << i
-      kk = %[#{@key}-#{VK.redis.call("LLEN",@key)}]
-      VK.redis.call("SET", kk, i);
-      VK.redis.call("RPUSH", key, kk)
-    end
-    def []= k,v
-      kk = %[#{@key}-#{k}]
-	  VK.redis.call("SET", kk, v)
-	  VK.redis.call("RPUSH", key, kk);
-    end
-    def nearest p
-      h = {}
-      value { |i,v|
-        h[i] = {
-                value: v,
-                levenshtein: p.levenshtein_similar(v),
-                damerau: p.damerau_levenshtein_similar(v),
-                hamming: p.hamming_similar(v),
-                distance: p.pair_distance_similar(v),
-                subsequence: p.longest_subsequence_similar(v),
-                substring: p.longest_substring_similar(v),
-                jaro: p.jaro_similar(v),
-                winkler: p.jarowinkler_similar(v)
-              }
-      }
-      return h
-    end
-  end 
-  
-  class COUNTER < O
-    def incr n
-      VK.redis.call("SET", @key, value + n.to_f)
+    def expire(seconds)
+      valkey.expire(key, seconds)
     end
-    def decr n
-      VK.redis.call("SET", @key, value - n.to_f)
-    end    
-    def value
-      x = VK.redis.call("GET", @key).to_f
-      if @opts.has_key?(:flush) == true                                                                                                               
-        delete!                                                                                                                                       
-      end
-      return x
+
+    def expireat(unix_timestamp)
+      valkey.expireat(key, unix_timestamp)
+    end
+
+    def ttl
+      valkey.ttl(key)
     end
-    def value= n
-      VK.redis.call("SET", @key, n.to_f)
+
+    def persist
+      valkey.persist(key)
+    end
+    
+    def to_i
+      value.to_i
     end
-    def exist?                                                                                                                                        
-      VK.redis.call("GET", @key) ? true : false                                                                                                        
-    end    
   end
   
-  class HASH < O
-    def [] k
-      VK.redis.call("HGET", key, k);
+  # List wrapper
+  class List
+    include Enumerable
+    attr_reader :key, :valkey
+    
+    def initialize(key, valkey)
+      @key = key
+      @valkey = valkey
+    end
+    
+    def <<(value)
+      valkey.rpush(key, value)
+    end
+    
+    def push(*values)
+      valkey.rpush(key, values)
+    end
+    
+    def unshift(*values)
+      valkey.lpush(key, values.reverse)
+    end
+    
+    def pop
+      valkey.rpop(key)
+    end
+    
+    def shift
+      valkey.lpop(key)
+    end
+    
+    def [](index)
+      valkey.lindex(key, index)
+    end
+    
+    def []=(index, value)
+      valkey.lset(key, index, value)
+    end
+    
+    def length
+      valkey.llen(key)
     end
-    def []= k,v
-      VK.redis.call("HSET", key, k, v);
+    alias_method :size, :length
+    
+    def range(start_idx, end_idx)
+      valkey.lrange(key, start_idx, end_idx)
     end
-    def update(h={})
-		h.each_pair { |k,v| VK.redis.call("HSET", key, k, v); }
+    
+    def values
+      range(0, -1)
     end
-    def to_h
-      VK.redis.call("HGETALL", key);
+    
+    def each(&block)
+      values.each(&block)
+    end
+
+    def expire(seconds)
+      valkey.expire(key, seconds)
+    end
+
+    def expireat(unix_timestamp)
+      valkey.expireat(key, unix_timestamp)
+    end
+
+    def ttl
+      valkey.ttl(key)
+    end
+
+    def persist
+      valkey.persist(key)
+    end
+    
+    ### KNN ###
+    def knn
+      KNN.new(values)
+    end
+    
+    
+    def clear
+      valkey.del(key)
+    end
+    
+    def delete
+      clear
     end
   end
   
-  class QUEUE < O
-    def value &b
-      VK.redis.call("LRANGE", key, 0, -1).each_with_index { |e, i| b.call(i, e) }
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
+  # Set wrapper
+  class Set
+    include Enumerable
+    attr_reader :key, :valkey
+    
+    def initialize(key, valkey)
+      @key = key
+      @valkey = valkey
+    end
+    
+    def add(value)
+      valkey.sadd(key, value)
+    end
+    alias_method :<<, :add
+    
+    def remove(value)
+      valkey.srem(key, value)
+    end
+    
+    def member?(value)
+      valkey.sismember(key, value)
+    end
+    alias_method :include?, :member?
+    
+    def members
+      valkey.smembers(key)
+    end
+    alias_method :to_a, :members
+    
+    def size
+      valkey.scard(key)
+    end
+    alias_method :length, :size
+    
+    def each(&block)
+      members.each(&block)
     end
-    def last
-		VK.redis.call("LRANGE", key, -1,-1)[0]
+
+    def expire(seconds)
+      valkey.expire(key, seconds)
     end
-    def length
-      VK.redis.call("LLEN", key)
-    end      
-    def << i
-      VK.redis.call("RPUSH", key, i)
+
+    def expireat(unix_timestamp)
+      valkey.expireat(key, unix_timestamp)
     end
-    def front
-      VK.redis.call("LPOP", key)
+
+    def ttl
+      valkey.ttl(key)
+    end
+
+    def persist
+      valkey.persist(key)
+    end
+    
+    ### KNN ###                                                                                                                                                                                                   
+    def knn
+      KNN.new(members)
+    end    
+    
+    def clear
+      valkey.del(key)
+    end
+    
+    def delete
+      clear
     end
   end
   
-  class SORTEDSET < O
-    def value &b
-      VK.redis.call("ZREVRANGE", key, 0, -1, 'WITHSCORES').each_with_index { |e, i| b.call(i, e) }
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
+  # Hash wrapper
+  class HashKey
+    include Enumerable
+    attr_reader :key, :valkey
+
+    def initialize(key, valkey)
+      @key = key
+      @valkey = valkey
     end
-    def to_h
-		h = {}
-		VK.redis.call("ZREVRANGE", key, 0, -1, 'WITHSCORES').each_with_index { |e, i| h[e[0]] = e[1] }
-		return h
+
+    def [](field)
+      valkey.hget(key, field)
     end
-    def [] k
-      VK.redis.call("ZSCORE", key, k).to_f;
+
+    def []=(field, value)
+      valkey.hset(key, field, value)
     end
-    def []= k,v
-      VK.redis.call("ZADD", key, v, k).to_f;
-    end      
-    def poke k, n
-      VK.redis.call("ZINCRBY", key, n.to_f, k);
+
+    def fetch(field, default = nil)
+      valkey.hget(key, field) || default
     end
-  end
 
-  class SET < O
-    def value &b
-      a = Set.new
-      VK.redis.call("SMEMBERS", key).each_with_index { |e, i|
-        if block_given?
-          a << b.call(i, e)
-        else
-          a << e
-        end
-      }
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
-      return a
+    def delete(field)
+      valkey.hdel(key, field)
     end
-    def include? k
-      if VK.redis.call("SMISMEMBER", key, k)[0] == 0
-        return false
-      else
-        return true
-      end
+
+    def key?(field)
+      valkey.hexists(key, field)
     end
-    def length
-      VK.redis.call("SCARD", key)
+    alias_method :has_key?, :key?
+
+    def keys
+      valkey.hkeys(key)
     end
-    def << i
-      VK.redis.call("SADD", key, i)
+
+    def values
+      valkey.hvals(key)
     end
-    def rm i
-      VK.redis.call("SREM", key, i)
-    end      
-    def & k
-      VK.redis.call("SINTER", key, k.key)
+
+    def all
+      valkey.hgetall(key)
     end
-    def | k
-      VK.redis.call("SUNION", key, k.key)
-    end      
-    def [] k
-      r, h = Regexp.new(k), {}
-      VK.redis.call("SMEMBERS", key).each { |e| if m = r.match(e); h[e] = m; end; }
-      return h
+    alias_method :to_h, :all
+
+    def size
+      valkey.hlen(key)
     end
-    def to_a
-		VK.redis.call("SMEMBERS", key)
+    alias_method :length, :size
+
+    def expire(seconds)
+      valkey.expire(key, seconds)
     end
-  end
-  
-  class PLACE < O
-    def value &b
-      a = []
-      VK.redis.call("ZRANGE", key, 0, -1).each_with_index { |e, i|
-        if block_given?
-          a << b.call(i, e)
-        else
-          a << e
-        end
-      };
-      if @opts.has_key?(:flush) == true
-        delete!
-      end
-      return a
+
+    def expireat(unix_timestamp)
+      valkey.expireat(key, unix_timestamp)
     end
-    def add i, lon, lat
-      VK.redis.call("GEOADD", key, lon, lat, i)
+
+    def ttl
+      valkey.ttl(key)
     end
-    def [] i
-      x = VK.redis.call("GEOPOS", key, i)[0];
-      return { longitude: x[0], latitude: x[1] }
+
+    def persist
+      valkey.persist(key)
     end
-    def distance a, b
-      VK.redis.call("GEODIST", key, a, b, 'm').to_f;
+    
+    def each(&block)
+      all.each(&block)
     end
-    def radius lon, lat, r
-      h = {}
-      VK.redis.call("GEORADIUS", key, lon, lat, r, 'm', 'WITHDIST').each { |e| h[e[0]] = e[1].to_f };
-      return h
+
+    def clear
+      valkey.del(key)
     end
   end
 
-  class SORTEDHASH < O
-    def value &b
-      VK.redis.call("ZREVRANGE", key, 0, -1, 'WITHSCORES').each_with_index { |e, i|
-        kx = %[#{@key}-#{e[0]}]
-        a = []
-        if block_given?
-          b.call(i, { key: e[0], value: VK.redis.call("GET", kx), score: e[1] } )
-        else
-          a << { key: e[0], value: VK.redis.call("GET", kx), score: e[1] }
-        end
-        if @opts.has_key?(:flush) == true
-          VK.redis.call("DEL", kx)
-        end
-      }
-      if @opts.has_key?(:flush) == true                                                                                                               
-        delete!                                                                                                                                       
+  # Sorted Set wrapper
+  class SortedSet
+    include Enumerable
+    attr_reader :key, :valkey
+
+    def initialize(key, valkey)
+      @key = key
+      @valkey = valkey
+    end
+
+    def add(member, score)
+      valkey.zadd(key, score, member)
+    end
+    alias_method :[]=, :add
+
+    def score(member)
+      if !member?(member)
+        add(member, 0)
       end
-      return a
+      return valkey.zscore(key, member).to_f
     end
-    def [] k
-      kx = %[#{@key}-#{k}]
-      VK.redis.call("GET", kx)
+    alias_method :[], :score
+
+    def remove(member)
+      valkey.zrem(key, member)
     end
-    def []= k, v
-      kx = %[#{@key}-#{k}]
-      VK.redis.call("SET", kx, v)
-      VK.redis.call("ZINCRBY", key, 1, k)
+
+    def member?(member)
+      !valkey.zscore(key, member).nil?
     end
-  end
+    alias_method :include?, :member?
 
-  class HASHLIST < O
-    def value &b
-      a = []
-      VK.redis.call("LRANGE", key, 0, -1).each_with_index { |e, i|
-        if block_given?
-          a << b.call(i, JSON.parse(VK.redis.call("GET", e)))
-        else
-          a << JSON.parse(VK.redis.call("GET", e))
-        end
-        if @opts.has_key?(:flush) == true
-          VK.redis.call("DEL", e)
-        end
-      }
-      if @opts.has_key?(:flush) == true
-        delete!
+    def range(start_idx, end_idx, with_scores: true)
+      if with_scores
+        valkey.zrange(key, start_idx, end_idx, with_scores: true)
+      else
+        valkey.zrange(key, start_idx, end_idx)
       end
-      return a
-    end
-    def length
-      VK.redis.call("LLEN", key)
     end
-    def [] k
-      hx = %[#{key}-#{k}]
-      JSON.parse(VK.redis.call("GET", hx));      
+
+    def revrange(start_idx, end_idx, with_scores: true)
+      if with_scores
+        valkey.zrevrange(key, start_idx, end_idx, with_scores: true)
+      else
+        valkey.zrevrange(key, start_idx, end_idx)
+      end
     end
-    def push h={}
-      hx = %[#{key}-#{length}]
-      VK.redis.call("SET", hx, JSON.generate(h));
-      VK.redis.call("RPUSH", key, hx)
-      return hx
+
+    def members
+      range(0, -1)
     end
-    def first
-		VK.redis.call("LRANGE", key, 0, 0)[0]
+
+    def incr k, n
+      add(k, score(k) + n)
     end
-    def last
-		VK.redis.call("LRANGE", key, -1, -1)[0]
+
+    def decr k, n
+      add(k, score(k) - n)
     end
-  end
 
-  class CORPUS < O
-    def _set
-		%[#{key}-sset]
-    end
-    def _index
-		%[#{key}-hash]
-    end
-	def length
-	  VK.redis.call("SCARD", _set)
-	end
-	def value &b
-		VK.redis.call("HGETALL", _index).each_pair { |e, i| b.call(i, e) }
-	end
-	def [] i			
-		if VK.redis.call("SMISMEMBER", _set, i)[0] == 0
-			VK.redis.call("SADD", _set, i)
-			VK.redis.call("HSET", _index, i, length);
-		end
-		return VK.redis.call("HGET", _index, i)
-	end
-  end
+    def up n, *a
+      [a].flatten.compact.each { |e| incr(e, n) }
+    end
 
-  class BOOK < O
-    def _set
-		%[#{key}-sset]
+    def dn n, *a
+      [a].flatten.compact.each { |e| decr(e, n) }
     end
-    def _index
-		%[#{key}-index]
+    
+    ### KNN ###                                                                                                                                                                                                   
+    def knn
+      KNN.new(members.map { |e| e[0] })
     end
-    def _sec
-		%[#{key}-sec]
-    end    
-    def _embed
-		%[#{key}-embed]
-    end
-	def length
-	  VK.redis.call("SCARD", _set)
-	end
-	def value &b
-		VK.redis.call("HGETALL", _index).each_pair { |e, i| b.call(i.to_i, e) }
-	end
-	def entry
-		Hash.new { |h,k| VK.redis.call("HGET", _sec, k) }
-	end
-	def vectors
-		a = []
-		value { |i, e| a << [ i, VK.embed(e) ].flatten }		
-		return a
-	end
-	def embed
-		return KNN.new(vectors, :distance_measure => :tanimoto_coefficient)
-	end
-	def near g, *n
-		 return embed.nearest_neighbours(VK.embed(g)).map { |e|
-			{ index: e[0], distance: e[1], entry: entry[e[0]] }
-		 }.sort_by { |ee| ee[:distance] }
-	end
-	def [] i			
-		if VK.redis.call("SMISMEMBER", _set, i.to_s)[0] == 0
-			VK.redis.call("HSET", _index, i.to_s, length.to_s);
-			VK.redis.call("HSET", _sec, length.to_s, i.to_s);
-			VK.redis.call("SADD", _set, i)
-		end
-		return VK.redis.call("HGET", _index, i.to_s).to_i;
-	end
-  end
+    
+    def size
+      valkey.zcard(key)
+    end
+    alias_method :length, :size
 
-	@@SENTIMENT_THRESHOLD = 0.9
-	##
-	# Bayesean Classification
-	#
-	# Determine the A OR B of an example.
-	##
-	# VK.classify("catagory A", "Catagory B").
-	def self.classify a, b
-		ClassifierReborn::Bayes.new a, b
-	end
-	
-	def self.threshold= n
-		@@SENTIMENT_THRESHOLD = n
-	end
-	##
-	# Sentiment Analysis.
-	##
-	# VK.feels("Some text")
-	def self.feels x
-		Sentimental.new(threshold: @@SENTIMENT_THRESHOLD).sentiment
-	end
-
-	@@CRi = Hash.new { |h,k| h[k] = CRi.new(k) }
-	class CRi
-		def initialize k
-			@id = k
-			@lsi = ClassifierReborn::LSI.new
-		end
-		def learn x, i
-			@lsi.add_item x.to_s, i.to_sym
-		end
-		def [] k
-			@lsi.classify k
-		end
-		def search x, *n
-			@lsi.search(x, n[0])
-		end
-	end
-	##
-	# Vector Indexing
-	# 
-	# Vector (of text) -> concept (index)
-	# - Find text concept based upon known examples.
-	# - Learn new examples of a concept.
-	# - Find examples from within clusters.
-	##
-	# index[:vector]['Text to classify'] => :index
-	# index[:vector].learn("Text to classify", :index)
-	# index[:vector].search("Similar text.", 5) => ["Similar text?", "other similar text", ...]
-	def self.index
-		@@CRi
-	end
-	@@VI = Hash.new { |h,k| h[k] = [] }
-	@@VC = Hash.new { |h,k| h[k] = Knn::Classifier.new(@@VI[k], SquaredEuclideanCalculator) }
-	def self.learn fact, index
-		@@CRi[index.to_sym].learn fact, index
-		@@VI[index] << fact
-	end
-
-	@@TOKENIZER = Tokenizer::WhitespaceTokenizer.new(:en)
-  def self.tokenize i
-  	@@TOKENIZER.tokenize(i)	
-  end
+    def each(&block)
+      members.each(&block)
+    end
+    
+    def expire(seconds)
+      valkey.expire(key, seconds)
+    end
 
-  @@WORDLIST = CORPUS.new(%[WORDLIST])
-  def self.wordlist
-	@@WORDLIST
-  end
+    def expireat(unix_timestamp)
+      valkey.expireat(key, unix_timestamp)
+    end
 
-  def self.embed i
-	m = VK.tokenize(i).map { |e| VK.wordlist[e].to_f }
-	return [m, Array.new(2048 - m.length, 0.0)].flatten
-  end
-  
-  def self.flushdb!
-    VK.redis.call("FLUSHDB")
-  end
+    def ttl
+      valkey.ttl(key)
+    end
 
-  def self.keys k='*'
-    VK.redis.call("KEYS", k)
-  end
+    def persist
+      valkey.persist(key)
+    end
+    
+    def clear
+      valkey.del(key)
+    end
 
-  def self.txt f, &b
-	x = File.read(f).gsub(/\n\n+/,"\n\n").gsub(/  +/, " ").split("\n\n").map { |e| e.gsub(/\n/, " ") }
-	if block_given?
-		x.map { |e| b.call(e) }
-	else
-		return x
-	end
+    def delete
+      clear
+    end
   end
 end