lizarb 1.0.5 → 1.0.6

data/lib/art_system/commands/deepseek_command.rb

@@ -0,0 +1,58 @@
+class ArtSystem::DeepseekCommand < DevSystem::SimpleCommand
+
+
+  section :filters
+
+  def before
+    super
+    @t = Time.now
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+
+  def after
+    super
+    log "#{ time_diff @t }s | done"
+  end
+
+  section :actions
+
+  # liza deepseek s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_default
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+    call_chat
+
+  rescue => e
+    log "rescued from (#{e.class}) #{e.message}"
+    binding.irb
+  end
+
+  # liza deepseek:chat s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_chat
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    set_default_arg(0, "Hello!")
+    content = simple_args.join(" ")
+
+    set_default_string :model, "deepseek-chat"
+    model = simple_string(:model)
+
+    shell = DeepseekShell.new
+    client = shell.client
+    response = client.chat(
+      parameters: {
+        model: model,
+        messages: [{ role: "user", content: content}],
+        temperature: 0.7
+      }
+    )
+    log response
+    puts response.dig("choices", 0, "message", "content")
+
+  rescue => e
+    log "#{e.class}: #{e.message}"
+    binding.irb
+  end
+
+end

data/lib/art_system/commands/deepseek_command_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::DeepseekCommandTest < DevSystem::SimpleCommandTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::DeepseekCommand
+    assert_equality subject.class, ArtSystem::DeepseekCommand
+  end
+
+end

data/lib/art_system/commands/ollama_command.rb

@@ -0,0 +1,69 @@
+class ArtSystem::OllamaCommand < DevSystem::SimpleCommand
+
+  section :filters
+
+  def before
+    super
+    @t = Time.now
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+  
+  def after
+    super
+    log "#{ time_diff @t }s | done"
+  end
+
+  section :actions
+
+  # liza ollama s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_default
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    call_chat
+  end
+
+  # liza ollama:chat s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_chat
+    log stick :b, system.color, "I just think Ruby is the Best for coding!"
+
+    content = args.join(" ")
+    content = "Hello!" if content.empty?
+    log "content: #{ content }"
+
+    # model = "llama3.3"
+    # model = "deepseek"
+    model = "tinyllama"
+    messages = [{ role: "user", content: content}]
+    temperature = 0.7
+
+    shell = OllamaShell.new
+    client = shell.client
+    response = client.chat(
+      parameters: {
+        model:,
+        messages:,
+        temperature:,
+      }
+    )
+    log response
+    puts response.dig("choices", 0, "message", "content")
+
+  rescue => e
+    log "rescued from (#{e.class}) #{e.message}"
+
+    log "consider running these commands"
+
+    puts
+    puts "docker ps"
+    puts "docker exec -it CONTAINER_ID sh"
+    puts "docker exec -it CONTAINER_ID ollama list"
+    puts "docker exec -it CONTAINER_ID ollama pull tinyllama"
+    puts "docker exec -it CONTAINER_ID ollama pull deepseek"
+    puts
+
+    binding.irb
+  end
+
+end

data/lib/art_system/commands/ollama_command_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::OllamaCommandTest < DevSystem::SimpleCommandTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::OllamaCommand
+    assert_equality subject.class, ArtSystem::OllamaCommand
+  end
+
+end

data/lib/art_system/gem_shells/ruby_openai_gem_shell.rb

@@ -0,0 +1,32 @@
+class ArtSystem::RubyOpenaiGemShell < DevSystem::GemShell
+  require "openai"
+  # gem install ruby-openai
+
+  section :use_case_1
+
+  def self.count_tokens(text)
+    call({})
+    c = OpenAI.rough_token_count(text)
+    log "count_tokens: #{ c }"
+    c
+  end
+
+  section :use_case_2
+
+  def self.get_client(client_options = {})
+    call({})
+    client_options = get_default_configuration.merge(client_options)
+    OpenAI::Client.new(client_options) do |faraday|
+      faraday.response :logger, Logger.new($stdout), bodies: true if log? :high
+    end
+  end
+
+  def self.get_default_configuration
+    {
+      log_errors: $coding,
+      # uri_base: "https://api.openai.com/v1",
+      # access_token: ENV.fetch("OPENAI_ACCESS_TOKEN")
+    }
+  end
+
+end

data/lib/art_system/gem_shells/ruby_openai_gem_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::RubyOpenaiGemShellTest < DevSystem::GemShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::RubyOpenaiGemShell
+    assert_equality subject.class, ArtSystem::RubyOpenaiGemShell
+  end
+
+end

data/lib/art_system/shells/deepseek_shell.rb

@@ -0,0 +1,15 @@
+class ArtSystem::DeepseekShell < DevSystem::Shell
+
+  attr_accessor :client
+
+  def initialize(access_token: nil, uri_base: nil)
+    access_token ||= ENV.fetch 'DEEPSEEK_ACCESS_TOKEN'
+    uri_base ||= ENV.fetch 'DEEPSEEK_URI_BASE'
+
+    client_options = {access_token:, uri_base:}
+
+
+    self.client = RubyOpenaiGemShell.get_client(client_options)
+  end
+
+end

data/lib/art_system/shells/deepseek_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::DeepseekShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::DeepseekShell
+    assert_equality subject.class, ArtSystem::DeepseekShell
+  end
+
+end

data/lib/art_system/shells/ollama_shell.rb

@@ -0,0 +1,12 @@
+class ArtSystem::OllamaShell < DevSystem::Shell
+
+  attr_accessor :client
+
+  def initialize(access_token: nil, uri_base: nil)
+    uri_base ||= ENV.fetch "OLLAMA_URI_BASE"
+    client_options = {access_token:, uri_base:}
+
+    self.client = RubyOpenaiGemShell.get_client(client_options)
+  end
+
+end

data/lib/art_system/shells/ollama_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::OllamaShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::OllamaShell
+    assert_equality subject.class, ArtSystem::OllamaShell
+  end
+
+end

data/lib/art_system/shells/openai_shell.rb

@@ -0,0 +1,13 @@
+class ArtSystem::OpenaiShell < DevSystem::Shell
+
+  attr_accessor :client
+
+  def initialize(access_token: nil, uri_base: nil)
+    access_token ||= ENV.fetch "OPENAI_ACCESS_TOKEN"
+    uri_base ||= ENV["OPENAI_URI_BASE"]
+    client_options = {access_token:, uri_base:}
+
+    self.client = RubyOpenaiGemShell.get_client(client_options)
+  end
+
+end

data/lib/art_system/shells/openai_shell_test.rb

@@ -0,0 +1,10 @@
+class ArtSystem::OpenaiShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, ArtSystem::OpenaiShell
+    assert_equality subject.class, ArtSystem::OpenaiShell
+  end
+
+end

data/lib/crypto_system/crypto_system_test.rb

@@ -0,0 +1,3 @@
+class CryptoSystem::CryptoSystemTest < Liza::SystemTest
+
+end

data/lib/crypto_system/gem_shells/digest_md5_gem_shell.rb

@@ -0,0 +1,15 @@
+class CryptoSystem::DigestMd5GemShell < DevSystem::GemShell
+  require "digest/md5"
+
+  def self.digest_hex(menv)
+    s = menv[:digest_hex_in] = menv[:digest_hex_in].to_s
+    call(menv)
+
+    ret = Digest::MD5.hexdigest(s)
+    menv[:digest_hex_out] = ret
+
+    log "digest_hex_in: #{s.size} bytes,  digest_hex_out: #{ret.size} bytes"
+    menv
+  end
+
+end

data/lib/crypto_system/gem_shells/digest_md5_gem_shell_test.rb

@@ -0,0 +1,25 @@
+class CryptoSystem::DigestMd5GemShellTest < DevSystem::GemShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, CryptoSystem::DigestMd5GemShell
+    assert_equality subject.class, CryptoSystem::DigestMd5GemShell
+  end
+
+  def digest_hex(s)
+    menv = {digest_hex_in: s}
+    subject_class.digest_hex(menv)
+    menv[:digest_hex_out]
+  end
+
+  test :digest_hex do
+    assert_equality digest_hex("hello"), "5d41402abc4b2a76b9719d911017c592"
+    assert_equality digest_hex(""),      "d41d8cd98f00b204e9800998ecf8427e"
+    assert_equality digest_hex(nil),     "d41d8cd98f00b204e9800998ecf8427e"
+    assert_equality digest_hex("0"),     "cfcd208495d565ef66e7dff9f98764da"
+    assert_equality digest_hex(0),       "cfcd208495d565ef66e7dff9f98764da"
+    assert_equality digest_hex(0.0),     "30565a8911a6bb487e3745c0ea3c8224"
+  end
+
+end

data/lib/deep_system/deep_system_test.rb

@@ -0,0 +1,3 @@
+class DeepSystem::DeepSystemTest < Liza::SystemTest
+
+end

data/lib/desk_system/commands/glimmer_command.rb

@@ -18,6 +18,7 @@ class DeskSystem::GlimmerCommand < DevSystem::SimpleCommand
     puts
     log "args = #{env[:args].inspect}"
     # require "glimmer-dsl-libui"
+    require "csv"
     require "examples/meta_example"
     
     log "done at #{Time.now}"

data/lib/desk_system/desk_system_test.rb

@@ -0,0 +1,3 @@
+class DeskSystem::DeskSystemTest < Liza::SystemTest
+
+end

data/lib/dev_system/commands/test_command.rb

@@ -1,113 +1,152 @@
-class DevSystem::TestCommand < DevSystem::Command
+class DevSystem::TestCommand < DevSystem::SimpleCommand
 
-  def self.call args
-    log "args = #{args.inspect}"
+  def before
+    super
+
+    set_default_array :domains, AppShell.get_writable_domains.keys
+    set_default_boolean :run, true
+    
+    set_input_array :domains do |default|
+      domains = AppShell.get_writable_domains
+      title = "Which domains are we going to test?"
+      InputShell.pick_domains domains, default, title
+    end
+  end
+
+  def call_default
+    Lizarb.eager_load!
+    DevBox[:log].sidebar_size 60
+    _call_silence_other_units
 
     now = Time.now
-    test_classes = Liza::Test.descendants
 
-    if args.any?
-      test_classes = test_classes.select { |tc| args.any? { tc.source_location_radical.snakecase.include? _1.snakecase } }
-    end
+    app_shell = build_filters
 
-    _call_silence_base_units
-    
-    if Lizarb::IS_APP_DIR
-      test_classes = test_classes.select { |tc| tc.source_location[0].include? Lizarb::APP_DIR }
+    set_input_boolean :run do |default|
+      InputShell.yes? "Do you want to run the tests?", default: default
     end
 
-    test_classes = _call_sort test_classes
-
+    should_run = simple_boolean(:run)
+    test_classes = app_shell.get_lists.flatten
     log "Testing #{test_classes}"
-    _call_testing test_classes
+    _call_testing test_classes if should_run
     log "Done Testing (#{now.diff}s)"
 
     puts
 
     log "Counting #{test_classes.count} Test Classes"
-    _call_counting test_classes
+    _call_counting app_shell
     log "Done Counting (#{now.diff}s)"
   end
 
-  def self._call_silence_base_units
+  def _call_silence_other_units
     [
+      Liza::Part,
+      Liza::System,
       Liza::Box,
       Liza::Panel,
       Liza::Controller,
     ].each do |x|
-      def x.log(...) end
-      def x.puts(...) end
+      x.class_eval do
+        def self.log(...) super(...) if self == TestCommand end
+        def self.puts(...) super(...) if self == TestCommand end
+        def log(...) super(...) if self.class == TestCommand end
+        def puts(...) super(...) if self.class == TestCommand end
+      end
     end
   end
 
-  def self._call_sort test_classes
-    test_classes.sort_by! &:name
-
-    proc_namespaced = proc { |tc| tc.name.include? "::" }
-    proc_liza = proc { |tc| tc.name[0..3] == "Liza" }
-
-    tc_app        = test_classes.reject(&proc_namespaced)
-    tc_namespaced = test_classes.select(&proc_namespaced)
-
-    tc_liza   = tc_namespaced.select(&proc_liza)
-    tc_system = tc_namespaced.reject(&proc_liza)
-
-    tc_app.sort_by! &:source_location
-    tc_liza.sort_by! &:source_location
-
-    [tc_liza, tc_system, tc_app].flatten
-  end
-
-  def self._call_testing test_classes
+  def _call_testing test_classes
     i, count = 0, test_classes.count
     for test_class in test_classes
       test_class.call i+=1, count
     end
   end
 
-
-  def self._call_counting test_classes
+  def _call_counting(app_shell)
     puts
     Liza.log ""
-    Liza.log stick :b, " TEST TOTALS ".center(140, "-")
+    Liza.log stick :b, :black, :white, " TEST TOTALS ".center(120, "-")
     Liza.log ""
     puts
     totals = Hash.new { 0 }
     last_namespace = nil
-    test_classes.each do |test_class|
-      namespace = test_class.first_namespace
-      puts if last_namespace != namespace
-      last_namespace = namespace
-
-      test_class.totals.each do |k, v|
-        totals[k] += v.size
+    app_shell.get_domains.each do |domain|
+      next if domain.empty?
+      puts
+      puts typo.h1 domain.name.to_s, domain.color, length: 120
+      puts
+
+      domain.layers.each do |layer|
+        next if layer.objects.empty?
+
+        m = "h#{layer.level}"
+        puts typo.send m, layer.name.to_s, layer.color, length: 120 unless layer.level == 1
+
+        puts stick layer.color, layer.path
+        puts
+
+        layer.objects.each do |object|
+          object.totals.each do |k, v|
+            totals[k] += v.size
+          end
+          size = 60 - object.to_s.size
+          total_line = object.totals.map do |k, v|
+            s = "#{k}: #{v.size}"
+            s = ":#{k} => #{v.size.to_s.rjust 2}"
+            s = stick :b, :white, :light_red, s    if k==:errors && v.size.positive?
+            s = stick :b, :black, :light_yellow, s if k==:fails  && v.size.positive?
+            s = stick :b, :white, :light_blue, s   if k==:todos  && v.size.positive?
+            s = stick :b, :light_green, s          if k==:passes && v.size.positive?
+            s
+          end
+          total_line = "{ #{ total_line.join(", ") } }"
+          Liza.log "#{typo.color_class object}#{" " * size} #{total_line}"
+        end
+        puts
       end
-      size = 60 - test_class.subject_class.to_s.size
-      Liza.log "#{_color_unit test_class.subject_class}#{".totals".ljust size} #{test_class.totals.map { |k, v| [k, v.size] }.to_h}"
     end
     puts
-    Liza.log "#{"Total".ljust 60} #{totals}"
+    totals_line = totals.map do |k, v|
+      s = "#{k}: #{v}"
+      s = ":#{k} => #{v.to_s.rjust 2}"
+      s = stick :b, :white, :light_red, s    if k==:errors && v.positive?
+      s = stick :b, :black, :light_yellow, s if k==:fails  && v.positive?
+      s = stick :b, :white, :light_blue, s   if k==:todos  && v.positive?
+      s = stick :b, :black, :light_green, s  if k==:passes && v.positive?
+      s
+    end
+    totals_line = "{ #{ totals_line.join(", ") } }"
+    Liza.log "#{"Total".ljust 60} #{totals_line}"
     puts
   end
 
-  def self._color_unit klass
-    return klass.to_s unless klass < Liza::Unit
-    return klass.to_s if klass.superclass == Liza::Unit
-
-    ret = ""
-    namespace, _sep, classname = klass.name.rpartition('::')
-    unless namespace.empty?
-      system_color = klass.system.color
-      ret << stick(namespace, system_color, :b).to_s
-      ret << "::"
+  def build_filters
+    app_shell = AppShell.new
+    app_shell.filter_by_unit Liza::Test
+
+    domains = simple_array(:domains)
+    log "domains = #{domains}"
+    app_shell.filter_by_domains domains
+
+    case simple_args.count
+    when 0
+      log "No filter"
+    when 1
+      name = simple_args[0]
+      log "Filter by name starting with #{name}"
+      app_shell.filter_by_starting_with name
+    else
+      case simple_args[0]
+      when "all"
+        log "Filter by all names"
+        app_shell.filter_by_including_all_names simple_args[1..]
+      else
+        app_shell.filter_by_including_any_name simple_args
+      end
     end
 
-    klass = klass.division if klass.is_a? Liza::Controller
-    unit_color = nil
-    unit_color = klass.system.color
-
-    ret << stick(classname, unit_color).to_s
-    ret
+    app_shell
   end
 
 end

data/lib/dev_system/commands/test_command_test.rb

@@ -1,11 +1,8 @@
-class DevSystem::TestCommandTest < DevSystem::CommandTest
+class DevSystem::TestCommandTest < DevSystem::SimpleCommandTest
 
   test :subject_class do
-    assert subject_class == DevSystem::TestCommand
-  end
-
-  test :settings do
-    assert_equality subject_class.log_level, 0
+    assert_equality subject_class, DevSystem::TestCommand
+    assert_equality subject.class, DevSystem::TestCommand
   end
 
 end

data/lib/dev_system/dev_box.rb

@@ -1,79 +1,38 @@
 class DevSystem::DevBox < Liza::Box
 
-  # Preconfigure your bench panel
-  
-  configure :bench do
-    # 
+  preconfigure :bench do
+    # BenchPanel.instance gives you read-access to this instance
   end
 
-  # Preconfigure your command panel
-  
-  configure :command do
-    # 
-    rescue_from CommandPanel::NotFoundError, with: NotFoundCommand
-  end
-
-  def self.command(...)
-    self[:command].call(...)
-  end
-
-  def self.input
-    self[:command].input
-  end
-  
-  def self.pick_one(...)
-    self[:command].pick_one(...)
-  end
-  
-  def self.pick_many(...)
-    self[:command].pick_many(...)
-  end
-  
-  # Preconfigure your generator panel
-  
-  configure :generator do
-    # 
-    rescue_from GeneratorPanel::NotFoundError, with: NotFoundGenerator
-  end
+  forward :bench
 
-  # Preconfigure your log panel
-
-  configure :log do
-    # 
-  end
-
-  # Preconfigure your shell panel
-
-  configure :shell do
-    # 
+  preconfigure :command do
+    # CommandPanel.instance gives you read-access to this instance
   end
 
-  def self.formatters
-    self[:shell].formatters
-  end
+  forward :command
+  forward :command, :input
+  forward :command, :pick_one
+  forward :command, :pick_many
 
-  def self.converters
-    self[:shell].converters
+  preconfigure :generator do
+    # GeneratorPanel.instance gives you read-access to this instance
   end
 
-  def self.converters_to
-    self[:shell].converters_to
-  end
+  forward :generator, :generate => :call
 
-  def self.format(...)
-    self[:shell].format(...)
+  preconfigure :log do
+    # LogPanel.instance gives you read-access to this instance
+    sidebar_size 50
   end
 
-  def self.format?(...)
-    self[:shell].format?(...)
-  end
+  forward :log, :logg => :call
 
-  def self.convert(...)
-    self[:shell].convert(...)
+  preconfigure :shell do
+    # ShellPanel.instance gives you read-access to this instance
   end
 
-  def self.convert?(...)
-    self[:shell].convert?(...)
-  end
+  forward :shell, :convert
+  forward :shell, :format
 
 end