scout-rig 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bcb31a6421de24abf3a11f37bcf00a295ffcf9d5163c55f02ccdb806ff54c4fb
+  data.tar.gz: b45379e2fb720a9e397faf467f7d3fcd9b14f0212096d40fcb62d2208a4936d1
+SHA512:
+  metadata.gz: cf8a3e4b67bdda6d867279d0b3e6166f5a942f0ee3a51d90105355121e8b2d8205b5f6468ec43c7cc487964d671bbeed73625815779fca633e64e4647e62a877
+  data.tar.gz: 8576a2ef1cd982db94fdab16ff207a1d9e7f189c125c5f92d4d0940091b452a64e69d3fa5af95f477131e8969686f47732ea79308c2f4f9734584e3ac3fbfffd

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.vimproject

@@ -0,0 +1,30 @@
+scout-rig=/$PWD filter="*" {
+ LICENSE.txt
+ README.rdoc
+ Rakefile
+ lib=lib {
+  scout-rig.rb
+  scout=scout{
+   python.rb
+   python=python{
+    paths.rb
+    run.rb
+    script.rb
+    util.rb
+   }
+  }
+ }
+ test=test{
+  test_helper.rb
+ }
+ python=python{
+  test.py
+  scout=scout{
+   __init__.py
+   workflow.py
+   workflow=workflow{
+    remote.py
+   }
+  }
+ }
+}

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2025 Miguel Vazquez
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,18 @@
+= scout-rig
+
+Description goes here.
+
+== Contributing to scout-rig
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2025 Miguel Vazquez. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+ENV["BRANCH"] = 'main'
+
+require 'rubygems'
+require 'rake'
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "scout-rig"
+  gem.homepage = "http://github.com/mikisvaz/scout-rig"
+  gem.license = "MIT"
+  gem.summary = %Q{Scouts rigging things together}
+  gem.description = %Q{Use other coding languages in your scout applications}
+  gem.email = "mikisvaz@gmail.com"
+  gem.authors = ["Miguel Vazquez"]
+
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "juwelier", "~> 2.1.0"
+
+  gem.add_runtime_dependency 'pycall', '> 0'
+end
+Juwelier::RubygemsDotOrgTasks.new
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "scout-rig #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/scout/python/paths.rb

@@ -0,0 +1,27 @@
+module ScoutPython
+  class << self
+    attr_accessor :paths
+    def paths
+      @paths ||= []
+    end
+  end
+
+  def self.add_path(path)
+    self.paths << path
+  end
+
+  def self.add_paths(paths)
+    self.paths.concat paths
+  end
+
+  def self.process_paths
+    ScoutPython.run_direct 'sys' do
+      ScoutPython.paths.each do |path|
+        sys.path.append path
+      end
+      nil
+    end
+  end
+
+  add_paths(Scout.python.find_all)
+end

data/lib/scout/python/run.rb

@@ -0,0 +1,122 @@
+module ScoutPython
+  class << self
+    attr_accessor :thread
+  end
+
+  class Binding
+    include PyCall::Import
+
+    def run(*args, &block)
+      instance_exec(*args, &block)
+    end
+  end
+
+  def self.thread
+    @thread ||= defined?(@thread) ? @thread : nil
+  end
+
+  MUTEX= Mutex.new
+  QUEUE_IN ||= Queue.new
+  QUEUE_OUT ||= Queue.new
+  def self.synchronize(&block)
+    MUTEX.synchronize &block
+  end
+
+  def self.init_thread
+    if defined?(self.thread) && (self.thread && ! self.thread.alive?)
+      Log.warn "Reloading ScoutPython thread"
+      self.thread.join
+      self.thread = nil
+    end
+
+    self.thread ||= Thread.new do
+      require 'pycall'
+      ScoutPython.process_paths
+      begin
+        while block = QUEUE_IN.pop
+          break if block == :stop
+          res = 
+            begin
+              module_eval(&block)
+            rescue Exception
+              Log.exception $!
+              raise $!
+            end
+
+          QUEUE_OUT.push res
+        end
+      rescue Exception
+        Log.exception $!
+        raise $!
+      ensure
+        PyCall.finalize if PyCall.respond_to?(:finalize)
+      end
+    end
+  end
+
+  def self.run_in_thread(&block)
+    self.synchronize do
+      init_thread
+      QUEUE_IN.push block
+      QUEUE_OUT.pop
+    end
+  end
+
+  def self.stop_thread
+    self.synchronize do
+      QUEUE_IN.push :stop
+    end if self.thread && self.thread.alive?
+    self.thread.join if self.thread
+  end
+
+  def self.run_direct(mod = nil, imports = nil, &block)
+    if mod
+      if Hash === imports
+        pyimport mod, **imports
+      elsif imports.nil?
+        pyimport mod 
+      else
+        pyfrom mod, :import => imports
+      end
+    end 
+
+    module_eval(&block)
+  end
+
+  def self.run_threaded(mod = nil, imports = nil, &block)
+    run_in_thread do
+        if Hash === imports
+          pyimport mod, **imports
+        elsif imports.nil?
+          pyimport mod 
+        else
+          pyfrom mod, :import => imports
+        end
+    end if mod
+
+    run_in_thread(&block)
+  end
+
+  def self.run_simple(mod = nil, imports = nil, &block)
+    self.synchronize do
+      ScoutPython.process_paths
+      run_direct(mod, imports, &block)
+    end
+  end
+
+  class << self
+    alias run run_simple
+  end
+
+  def self.run_log(mod = nil, imports = nil, severity = 0, severity_err = nil, &block)
+    Log.trap_std("Python STDOUT", "Python STDERR", severity, severity_err) do
+      run(mod, imports, &block)
+    end
+  end
+
+  def self.run_log_stderr(mod = nil, imports = nil, severity = 0, &block)
+    Log.trap_stderr("Python STDERR", severity) do
+      run(mod, imports, &block)
+    end
+  end
+end

data/lib/scout/python/script.rb

@@ -0,0 +1,110 @@
+module ScoutPython
+  def self.ruby2python(object)
+    case object
+    when Float::INFINITY
+      "inf"
+    when nil
+      "None"
+    when ":NA"
+      "None"
+    when Symbol
+      "#{ object }"
+    when String
+      object = object.dup if Path === object
+      object[0] == ":" ? object[1..-1] : "'#{ object }'"
+    when Numeric
+      object
+    when TrueClass
+      "True"
+    when FalseClass
+      "False"
+    when Array
+      "[#{object.collect{|e| ruby2python(e) } * ", "}]"
+    when Hash
+      "{" << object.collect{|k,v| [ruby2python(k.to_s), ruby2python(v)] * ":"} * ", " << "}"
+    else
+      raise "Type of object not known: #{ object.inspect }"
+    end
+  end
+
+  def self.load_script_variables(variables = {})
+    code = "# Variables\nimport scout\n"
+    tmp_files = []
+    variables.each do |name,value|
+      case value
+      when TSV
+        tmp_file = TmpFile.tmp_file
+        tmp_files << tmp_file
+        Open.write(tmp_file, value.to_s)
+        code << "#{name} = scout.tsv('#{tmp_file}')" << "\n"
+      else
+        code << "#{name} = #{ScoutPython.ruby2python(value)}" << "\n"
+      end
+    end
+
+    [code, tmp_files]
+  end
+
+  def self.save_script_result_pickle(file)
+    <<-EOF
+
+# Save
+try: result
+except NameError: result = None
+if result is not None:
+  import pickle
+  file = open('#{file}', 'wb')
+  # dump information to that file
+  pickle.dump(result, file)
+    EOF
+  end
+
+  def self.load_pickle(file)
+    require 'python/pickle'
+    Log.debug ("Loading pickle #{file}")
+    Python::Pickle.load_file(file)
+  end
+
+  def self.save_script_result_json(file)
+    <<-EOF
+
+# Save
+try: result
+except NameError: result = None
+if result is not None:
+  import json
+  file = open('#{file}', 'w', encoding='utf-8')
+  # dump information to that file
+  file.write(json.dumps(result))
+  file.flush
+  file.close
+    EOF
+  end
+
+  def self.load_json(file)
+    JSON.load_file(file)
+  end
+
+  class << self
+    alias save_script_result save_script_result_pickle
+    alias load_result load_pickle
+  end
+
+  def self.script(text, variables = {})
+    if variables.any?
+      variable_definitions, tmp_files = load_script_variables(variables)
+      text = variable_definitions + "\n# Script\n" + text
+    end
+
+    TmpFile.with_file do |tmp_file|
+      text += save_script_result(tmp_file)
+      Log.debug "Running python script:\n#{text.dup}"
+      path_env = ScoutPython.paths * ":"
+      CMD.cmd_log("env PYTHONPATH=#{path_env} python", {in: text})
+      tmp_files.each{|file| Open.rm_rf file } if tmp_files
+      if Open.exists?(tmp_file)
+        load_result(tmp_file)
+      end
+    end
+  end
+end

data/lib/scout/python/util.rb

@@ -0,0 +1,52 @@
+module ScoutPython
+  def self.py2ruby_a(array)
+    PyCall::List.(array).to_a
+  end
+
+  class << self
+    alias to_a py2ruby_a 
+  end
+
+  def self.tsv2df(tsv)
+    df = nil
+    ScoutPython.run_direct 'pandas' do
+      df = pandas.DataFrame.new(tsv.values, columns: tsv.fields, index: tsv.keys)
+      df.columns.name = tsv.key_field
+    end
+    df
+  end
+
+  def self.df2tsv(tuple, options = {})
+    options = IndiferentHash.add_defaults options, :type => :list
+    IndiferentHash.setup options
+    tsv = TSV.setup({}, options)
+    tsv.key_field = options[:key_field] || tuple.columns.name.to_s
+    tsv.fields = py2ruby_a(tuple.columns.values)
+    keys = py2ruby_a(tuple.index.values)
+    PyCall.len(tuple.index).times do |i|
+      k = keys[i]
+      tsv[k] = py2ruby_a(tuple.values[i])
+    end
+    tsv
+  end
+
+  def self.list2ruby(list)
+    return list unless PyCall::List === list 
+    list.collect do |e|
+      list2ruby(e)
+    end
+  end
+
+  def self.numpy2ruby(numpy)
+    list2ruby(numpy.tolist)
+  end
+
+  def self.obj2hash(obj)
+    hash = {}
+    ScoutPython.iterate obj.keys do |k|
+      hash[k] = obj[k]
+    end
+    hash
+  end
+end
+

data/lib/scout/python.rb

@@ -0,0 +1,140 @@
+require 'scout'
+require 'pycall/import'
+require_relative 'python/paths'
+require_relative 'python/run'
+
+module ScoutPython
+  extend PyCall::Import
+
+  class ScoutPythonException < StandardError; end
+
+  def self.init_scout
+    if ! defined?(@@__init_scout_python) || ! @@__init_scout_python
+      ScoutPython.process_paths
+      res = ScoutPython.run do
+        Log.debug "Loading python 'scout' module into pycall ScoutPython module"
+        pyimport("scout")
+      end
+      @@__init_scout_python = true
+    end
+  end
+
+  def self.import_method(module_name, method_name, as = nil)
+    init_scout
+    ScoutPython.pyfrom module_name, import: method_name
+    ScoutPython.method(method_name)
+  end
+
+  def self.call_method(module_name, method_name, *args)
+    ScoutPython.import_method(module_name, method_name).call(*args)
+  end
+  
+  def self.get_module(module_name)
+    init_scout
+    save_module_name = module_name.to_s.gsub(".", "_")
+    ScoutPython.pyimport(module_name, as: save_module_name)
+    ScoutPython.send(save_module_name)
+  end
+
+  def self.get_class(module_name, class_name)
+    mod = get_module(module_name)
+    mod.send(class_name)
+  end
+
+  def self.class_new_obj(module_name, class_name, args={})
+    ScoutPython.get_class(module_name, class_name).new(**args)
+  end
+
+  def self.exec(script)
+    PyCall.exec(script)
+  end
+
+  def self.iterate_index(elem, options = {})
+    bar = options[:bar]
+
+    len = PyCall.len(elem)
+    case bar
+    when TrueClass
+      bar = Log::ProgressBar.new nil, :desc => "ScoutPython iterate"
+    when String
+      bar = Log::ProgressBar.new nil, :desc => bar
+    end
+
+    len.times do |i|
+      begin
+        yield elem[i]
+        bar.tick if bar
+      rescue PyCall::PyError
+        if $!.type.to_s == "<class 'StopIteration'>"
+          break
+        else
+          raise $!
+        end
+      rescue
+        bar.error if bar
+        raise $!
+      end
+    end
+
+    Log::ProgressBar.remove_bar bar if bar
+    nil
+  end
+
+  def self.iterate(iterator, options = {}, &block)
+    if ! iterator.respond_to?(:__next__)
+      if iterator.respond_to?(:__iter__)
+        iterator = iterator.__iter__
+      else
+        return iterate_index(iterator, options, &block)
+      end
+    end
+
+    bar = options[:bar]
+
+    case bar
+    when TrueClass
+      bar = Log::ProgressBar.new nil, :desc => "ScoutPython iterate"
+    when String
+      bar = Log::ProgressBar.new nil, :desc => bar
+    end
+
+    while true
+      begin
+        elem = iterator.__next__
+        yield elem
+        bar.tick if bar
+      rescue PyCall::PyError
+        if $!.type.to_s == "<class 'StopIteration'>"
+          break
+        else
+          raise $!
+        end
+      rescue
+        bar.error if bar
+        raise $!
+      end
+    end
+
+    Log::ProgressBar.remove_bar bar if bar
+    nil
+  end
+
+  def self.collect(iterator, options = {}, &block)
+    acc = []
+    self.iterate(iterator, options) do |elem|
+      res = block.call elem
+      acc << res
+    end
+    acc
+  end
+
+  def self.new_binding
+    Binding.new
+  end
+
+  def self.binding_run(binding = nil, *args, &block)
+    binding = new_binding
+    binding.instance_exec *args, &block
+  end
+end
+

data/lib/scout-rig.rb

@@ -0,0 +1,5 @@
+require 'scout'
+require 'scout/path'
+require 'scout/resource'
+Path.add_path :scout_rig, File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}/{SUBPATH}")
+