rbbt-util 6.0.3 → 6.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e256d45aa4a4f9262d4d9a918f0336bc8b9af78de07af1b43cd9f4f9963c180b
-  data.tar.gz: 93edc17e9ef31a721d303ca9282b185f4035839795ff730b3d2592eb16657001
+  metadata.gz: b6312e564dc119b942bb279017a12bd3571f27b1caa57db746c62996e8c73407
+  data.tar.gz: f08802c255d5967bf211bf801fbeb7f91e9d2a82804f51393061ce422e7fc26e
 SHA512:
-  metadata.gz: b174c5a4f056d11b6ea62550a997cd6f55265bd036c310d4dab02e09a970f552a45073cc099326548004e0fc155eb305d3f5248acd3c7c4b4dfc9b879fc17c5b
-  data.tar.gz: c9df520b857e38361df51aa0c4867e98abe3a52421a1cca8861f175b498c65172ddee62d60b3d174c56d5b614109263954810dace7877c867217ef98c7716cf2
+  metadata.gz: 2f74e126c73d121853002d2918ef5cb8c9b181c7c2264d7eb7c9f4a4d78441fc6b026f1b27eca445613717fff6a8f0169f9aeb86d33afeafe2eebed696685cc3
+  data.tar.gz: 93ddc50c5c0f5b45e79449f81788405fada4ad9aabaeac1f6fd908765184a79220e2960472a460a973afedd31ae2ad389c60d67a80e4b82ae63ac70748bf8a25

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2022 Miguel Vázquez García
+Copyright (c) 2010-2024 Miguel Vázquez García
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/bin/rbbt_exec.rb

@@ -30,7 +30,7 @@ data = data * "\n" if Array === data
 
 case
 when (output.nil? or output == '-')
-  puts data
+  STDOUT.write data
 when output == "file"
   if Misc.filename? data
     tmpfile = data
@@ -39,7 +39,7 @@ when output == "file"
     Open.write(tmpfile, data.to_s)
   end
 
-  puts tmpfile
+  STDOUT.puts tmpfile
 else
   Open.write(output, data.to_s)
 end

data/lib/rbbt/tsv/excel.rb

@@ -1,5 +1,5 @@
-require_relative '../refactor'
 Rbbt.require_instead 'scout/tsv'
+require_relative '../refactor'
 require 'spreadsheet'
 require 'rubyXL'
 

data/lib/rbbt/util/filecache.rb

@@ -12,7 +12,7 @@ module FileCache
 
   def self.cachedir=(cachedir)
     CACHEDIR.replace cachedir
-    FileUtils.mkdir_p CACHEDIR unless File.exist? CACHEDIR
+    Open.mkdir CACHEDIR unless Open.exist? CACHEDIR
   end
 
   def self.cachedir

data/lib/rbbt/util/migrate.rb

@@ -6,7 +6,7 @@ module Rbbt
 require 'rbbt-util'
 path = "#{path}"
 if Open.exists?(path)
-  path = #{resource.to_s}.identify(path)
+  path = Path.setup(#{resource.to_s}.identify(path))
 else
   path = Path.setup(path)
 end

data/lib/rbbt/util/misc/system.rb

@@ -1,90 +1,92 @@
-module Misc
-
-  def self.hostname
-    @hostanem ||= `hostname`.strip
-  end
-
-  def self.pid_exists?(pid)
-    return false if pid.nil?
-    begin
-      Process.getpgid(pid.to_i)
-      true
-    rescue Errno::ESRCH
-      false
-    end
-  end
-
-  def self.env_add(var, value, sep = ":", prepend = true)
-    ENV[var] ||= ""
-    return if ENV[var] =~ /(#{sep}|^)#{Regexp.quote value}(#{sep}|$)/
-      if prepend
-        ENV[var] = value + sep + ENV[var]
-      else
-        ENV[var] += sep + ENV[var]
-      end
-  end
-
-  def self.with_env(var, value, &block)
-    var = var.to_s
-    value = value.to_s
-    current = ENV[var]
-    begin
-      ENV[var] = value
-      yield
-    ensure
-      ENV[var] = current
-    end
-  end
-
-  def self.common_path(dir, file)
-    file = File.expand_path file
-    dir = File.expand_path dir
-
-    return true if file == dir
-    while File.dirname(file) != file
-      file = File.dirname(file)
-      return true if file == dir
-    end
-
-    return false
-  end
-
-
-  def self.relative_link(source, target_dir)
-    path = "."
-    current = target_dir
-    while ! Misc.common_path current, source
-      current = File.dirname(current)
-      path = File.join(path, '..')
-      return nil if current == "/"
-    end
-
-    File.join(path, Misc.path_relative_to(current, source))
-  end
-
-  # WARN: probably not thread safe...
-  def self.in_dir(dir)
-    old_pwd = FileUtils.pwd
-    res = nil
-    begin
-      FileUtils.mkdir_p dir unless File.exist?(dir)
-      FileUtils.cd dir
-      res = yield
-    ensure
-      FileUtils.cd old_pwd
-    end
-    res
-  end
-
-  def self.is_filename?(string, need_to_exists = true)
-    return false if string.nil?
-    return true if defined? Path and Path === string
-    return true if string.respond_to? :exists
-    return true if String === string and ! string.include?("\n") and string.split("/").select{|p| p.length > 265}.empty? and (! need_to_exists || File.exist?(string))
-    return false
-  end
-
-  class << self
-    alias filename? is_filename?
-  end
-end
+require_relative 'refactor'
+Rbbt.require_instead 'scout/misc/format'
+#module Misc
+#
+#  def self.hostname
+#    @hostanem ||= `hostname`.strip
+#  end
+#
+#  def self.pid_exists?(pid)
+#    return false if pid.nil?
+#    begin
+#      Process.getpgid(pid.to_i)
+#      true
+#    rescue Errno::ESRCH
+#      false
+#    end
+#  end
+#
+#  def self.env_add(var, value, sep = ":", prepend = true)
+#    ENV[var] ||= ""
+#    return if ENV[var] =~ /(#{sep}|^)#{Regexp.quote value}(#{sep}|$)/
+#      if prepend
+#        ENV[var] = value + sep + ENV[var]
+#      else
+#        ENV[var] += sep + ENV[var]
+#      end
+#  end
+#
+#  def self.with_env(var, value, &block)
+#    var = var.to_s
+#    value = value.to_s
+#    current = ENV[var]
+#    begin
+#      ENV[var] = value
+#      yield
+#    ensure
+#      ENV[var] = current
+#    end
+#  end
+#
+#  def self.common_path(dir, file)
+#    file = File.expand_path file
+#    dir = File.expand_path dir
+#
+#    return true if file == dir
+#    while File.dirname(file) != file
+#      file = File.dirname(file)
+#      return true if file == dir
+#    end
+#
+#    return false
+#  end
+#
+#
+#  def self.relative_link(source, target_dir)
+#    path = "."
+#    current = target_dir
+#    while ! Misc.common_path current, source
+#      current = File.dirname(current)
+#      path = File.join(path, '..')
+#      return nil if current == "/"
+#    end
+#
+#    File.join(path, Misc.path_relative_to(current, source))
+#  end
+#
+#  # WARN: probably not thread safe...
+#  def self.in_dir(dir)
+#    old_pwd = FileUtils.pwd
+#    res = nil
+#    begin
+#      FileUtils.mkdir_p dir unless File.exist?(dir)
+#      FileUtils.cd dir
+#      res = yield
+#    ensure
+#      FileUtils.cd old_pwd
+#    end
+#    res
+#  end
+#
+#  def self.is_filename?(string, need_to_exists = true)
+#    return false if string.nil?
+#    return true if defined? Path and Path === string
+#    return true if string.respond_to? :exists
+#    return true if String === string and ! string.include?("\n") and string.split("/").select{|p| p.length > 265}.empty? and (! need_to_exists || File.exist?(string))
+#    return false
+#  end
+#
+#  class << self
+#    alias filename? is_filename?
+#  end
+#end

data/lib/rbbt/workflow/refactor/export.rb

@@ -1,66 +1,66 @@
-module Workflow
-
-  annotation :asynchronous_exports, :synchronous_exports, :exec_exports, :stream_exports
-
-  def asynchronous_exports
-    @asynchronous_exports ||= []
-  end
-
-  def synchronous_exports
-    @synchronous_exports ||= []
-  end
-
-  def exec_exports
-    @exec_exports ||= []
-  end
-
-  def stream_exports
-    @exec_exports ||= []
-  end
-
-
-  def all_exports
-    asynchronous_exports + synchronous_exports + exec_exports + stream_exports
-  end
-
-  alias task_exports all_exports
-
-  def unexport(*names)
-    names = names.collect{|n| n.to_s} + names.collect{|n| n.to_sym}
-    names.uniq!
-    exec_exports.replace exec_exports - names if exec_exports
-    synchronous_exports.replace synchronous_exports - names if synchronous_exports
-    asynchronous_exports.replace asynchronous_exports - names if asynchronous_exports
-    stream_exports.replace stream_exports - names if stream_exports
-  end
-  
-  def export_exec(*names)
-    unexport *names
-    exec_exports.concat names
-    exec_exports.uniq!
-    exec_exports
-  end
-
-  def export_synchronous(*names)
-    unexport *names
-    synchronous_exports.concat names
-    synchronous_exports.uniq!
-    synchronous_exports
-  end
-
-  def export_asynchronous(*names)
-    unexport *names
-    asynchronous_exports.concat names
-    asynchronous_exports.uniq!
-    asynchronous_exports
-  end
-
-  def export_stream(*names)
-    unexport *names
-    stream_exports.concat names
-    stream_exports.uniq!
-    stream_exports
-  end
-
-  alias export export_asynchronous
-end
+#module Workflow
+#
+#  annotation :asynchronous_exports, :synchronous_exports, :exec_exports, :stream_exports
+#
+#  def asynchronous_exports
+#    @asynchronous_exports ||= []
+#  end
+#
+#  def synchronous_exports
+#    @synchronous_exports ||= []
+#  end
+#
+#  def exec_exports
+#    @exec_exports ||= []
+#  end
+#
+#  def stream_exports
+#    @exec_exports ||= []
+#  end
+#
+#
+#  def all_exports
+#    asynchronous_exports + synchronous_exports + exec_exports + stream_exports
+#  end
+#
+#  alias task_exports all_exports
+#
+#  def unexport(*names)
+#    names = names.collect{|n| n.to_s} + names.collect{|n| n.to_sym}
+#    names.uniq!
+#    exec_exports.replace exec_exports - names if exec_exports
+#    synchronous_exports.replace synchronous_exports - names if synchronous_exports
+#    asynchronous_exports.replace asynchronous_exports - names if asynchronous_exports
+#    stream_exports.replace stream_exports - names if stream_exports
+#  end
+#  
+#  def export_exec(*names)
+#    unexport *names
+#    exec_exports.concat names
+#    exec_exports.uniq!
+#    exec_exports
+#  end
+#
+#  def export_synchronous(*names)
+#    unexport *names
+#    synchronous_exports.concat names
+#    synchronous_exports.uniq!
+#    synchronous_exports
+#  end
+#
+#  def export_asynchronous(*names)
+#    unexport *names
+#    asynchronous_exports.concat names
+#    asynchronous_exports.uniq!
+#    asynchronous_exports
+#  end
+#
+#  def export_stream(*names)
+#    unexport *names
+#    stream_exports.concat names
+#    stream_exports.uniq!
+#    stream_exports
+#  end
+#
+#  alias export export_asynchronous
+#end

data/lib/rbbt/workflow/refactor/recursive.rb

@@ -1,64 +1,64 @@
-module Workflow
-  def rec_inputs(task_name)
-    tasks[task_name].recursive_inputs.collect{|name, _| name }
-  end
-
-  def rec_input_types(task_name)
-    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
-      name, type, desc, default, options = l
-      acc.merge!(name => type) unless acc.include?(name)
-      acc
-    end
-  end
-
-
-  def rec_input_descriptions(task_name)
-    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
-      name, type, desc, default, options = l
-      acc.merge!(name => desc)  unless desc.nil? || acc.include?(name)
-      acc
-    end
-  end
-
-  def rec_input_defaults(task_name)
-    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
-      name, type, desc, default, options = l
-      acc.merge!(name => default)  unless default.nil? || acc.include?(name)
-      acc
-    end
-  end
-
-  def rec_input_options(task_name)
-    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
-      name, type, desc, default, options = l
-      acc.merge!(name => options) unless options.nil? unless acc.include?(name)
-      acc
-    end
-  end
-
-
-  def rec_input_use(task_name)
-    input_use = {}
-    task = self.tasks[task_name]
-    task.inputs.each do |name,_| 
-      input_use[name] ||= {} 
-      input_use[name][self] ||= []
-      input_use[name][self] << task_name
-    end
-
-    task.deps.inject(input_use) do |acc,p|
-      workflow, task_name = p
-      next if task_name.nil?
-      workflow.rec_input_use(task_name).each do |name,uses|
-        acc[name] ||= {}
-        uses.each do |workflow, task_names|
-          acc[name][workflow] ||= []
-          acc[name][workflow].concat(task_names)
-        end
-      end
-      acc
-    end if task.deps
-
-    input_use
-  end
-end
+#module Workflow
+#  def rec_inputs(task_name)
+#    tasks[task_name].recursive_inputs.collect{|name, _| name }
+#  end
+#
+#  def rec_input_types(task_name)
+#    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+#      name, type, desc, default, options = l
+#      acc.merge!(name => type) unless acc.include?(name)
+#      acc
+#    end
+#  end
+#
+#
+#  def rec_input_descriptions(task_name)
+#    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+#      name, type, desc, default, options = l
+#      acc.merge!(name => desc)  unless desc.nil? || acc.include?(name)
+#      acc
+#    end
+#  end
+#
+#  def rec_input_defaults(task_name)
+#    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+#      name, type, desc, default, options = l
+#      acc.merge!(name => default)  unless default.nil? || acc.include?(name)
+#      acc
+#    end
+#  end
+#
+#  def rec_input_options(task_name)
+#    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+#      name, type, desc, default, options = l
+#      acc.merge!(name => options) unless options.nil? unless acc.include?(name)
+#      acc
+#    end
+#  end
+#
+#
+#  def rec_input_use(task_name)
+#    input_use = {}
+#    task = self.tasks[task_name]
+#    task.inputs.each do |name,_| 
+#      input_use[name] ||= {} 
+#      input_use[name][self] ||= []
+#      input_use[name][self] << task_name
+#    end
+#
+#    task.deps.inject(input_use) do |acc,p|
+#      workflow, task_name = p
+#      next if task_name.nil?
+#      workflow.rec_input_use(task_name).each do |name,uses|
+#        acc[name] ||= {}
+#        uses.each do |workflow, task_names|
+#          acc[name][workflow] ||= []
+#          acc[name][workflow].concat(task_names)
+#        end
+#      end
+#      acc
+#    end if task.deps
+#
+#    input_use
+#  end
+#end

data/lib/rbbt/workflow/refactor/task_info.rb

@@ -1,65 +1,66 @@
-require_relative 'export'
-require_relative 'recursive'
-module Workflow
-  def task_info(name)
-    name = name.to_sym
-    task = tasks[name]
-    raise "No '#{name}' task in '#{self.to_s}' Workflow" if task.nil?
-    id = File.join(self.to_s, name.to_s)
-    @task_info ||= {}
-    @task_info[id] ||= begin 
-                         description = task.description
-                         result_description = task.result_description
-                         result_type = task.result_type
-
-                         inputs = rec_inputs(name).uniq
-                         input_types = rec_input_types(name)
-                         input_descriptions = rec_input_descriptions(name)
-                         input_use = rec_input_use(name)
-                         input_defaults = rec_input_defaults(name)
-                         input_options = rec_input_options(name)
-                         extension = task.extension
-                         export = case
-                                  when (synchronous_exports.include?(name.to_sym) or synchronous_exports.include?(name.to_s))
-                                    :synchronous
-                                  when (asynchronous_exports.include?(name.to_sym) or asynchronous_exports.include?(name.to_s))
-                                    :asynchronous
-                                  when (exec_exports.include?(name.to_sym) or exec_exports.include?(name.to_s))
-                                    :exec
-                                  when (stream_exports.include?(name.to_sym) or stream_exports.include?(name.to_s))
-                                    :stream
-                                  else
-                                    :none
-                                  end
-
-                         dependencies = tasks[name].deps
-                         { :id => id,
-                           :description => description,
-                           :export => export,
-                           :inputs => inputs,
-                           :input_types => input_types,
-                           :input_descriptions => input_descriptions,
-                           :input_defaults => input_defaults,
-                           :input_options => input_options,
-                           :input_use => input_use,
-                           :result_type => result_type,
-                           :result_description => result_description,
-                           :dependencies => dependencies,
-                           :extension => extension
-                         }
-                       end
-  end
-end
-
-module Task
-  def result_description
-    ""
-  end
-
-  def result_type
-    @returns
-  end
-
-end
-
-
+#require_relative 'export'
+#require_relative 'recursive'
+#module Workflow
+#  def task_info(name)
+#    name = name.to_sym
+#    task = tasks[name]
+#    raise "No '#{name}' task in '#{self.to_s}' Workflow" if task.nil?
+#    id = File.join(self.to_s, name.to_s)
+#    @task_info ||= {}
+#    @task_info[id] ||= begin 
+#                         description = task.description
+#                         result_description = task.result_description
+#                         returns = task.returns
+#
+#                         inputs = rec_inputs(name).uniq
+#                         input_types = rec_input_types(name)
+#                         input_descriptions = rec_input_descriptions(name)
+#                         input_use = rec_input_use(name)
+#                         input_defaults = rec_input_defaults(name)
+#                         input_options = rec_input_options(name)
+#                         extension = task.extension
+#                         export = case
+#                                  when (synchronous_exports.include?(name.to_sym) or synchronous_exports.include?(name.to_s))
+#                                    :synchronous
+#                                  when (asynchronous_exports.include?(name.to_sym) or asynchronous_exports.include?(name.to_s))
+#                                    :asynchronous
+#                                  when (exec_exports.include?(name.to_sym) or exec_exports.include?(name.to_s))
+#                                    :exec
+#                                  when (stream_exports.include?(name.to_sym) or stream_exports.include?(name.to_s))
+#                                    :stream
+#                                  else
+#                                    :none
+#                                  end
+#
+#                         dependencies = tasks[name].deps
+#                         { :id => id,
+#                           :description => description,
+#                           :export => export,
+#                           :inputs => inputs,
+#                           :input_types => input_types,
+#                           :input_descriptions => input_descriptions,
+#                           :input_defaults => input_defaults,
+#                           :input_options => input_options,
+#                           :input_use => input_use,
+#                           :returns => returns,
+#                           #:result_type => result_type,
+#                           #:result_description => result_description,
+#                           :dependencies => dependencies,
+#                           :extension => extension
+#                         }
+#                       end
+#  end
+#end
+#
+#module Task
+#  def result_description
+#    ""
+#  end
+#
+#  def result_type
+#    @returns
+#  end
+#
+#end
+#
+#

data/lib/rbbt/workflow/refactor.rb

@@ -1,6 +1,3 @@
-require_relative 'refactor/export'
-require_relative 'refactor/recursive'
-require_relative 'refactor/task_info'
 require_relative 'refactor/inputs'
 require_relative 'refactor/entity'
 

data/lib/rbbt/workflow/remote_workflow/driver/rest.rb

@@ -146,7 +146,6 @@ class RemoteWorkflow
                              task_info = RemoteWorkflow::REST.get_json(File.join(url, task.to_s, 'info'))
                              task_info = RemoteWorkflow.fix_hash(task_info)
 
-                             task_info[:result_type] = task_info[:result_type].to_sym
                              task_info[:export] = task_info[:export].to_sym
                              task_info[:input_types] = RemoteWorkflow.fix_hash(task_info[:input_types], true)
                              task_info[:inputs] = task_info[:inputs].collect{|input| input.to_sym }
@@ -248,7 +247,6 @@ class RemoteWorkflow
       end
     end
 
-
     def task_info(task)
       RemoteWorkflow::REST.task_info(url, task)
     end
@@ -260,6 +258,7 @@ class RemoteWorkflow
       @exec_exports = (task_exports["exec"] || []).collect{|task| task.to_sym }
       @stream_exports = (task_exports["stream"] || []).collect{|task| task.to_sym }
       @can_stream = task_exports["can_stream"]
+      (@asynchronous_exports + @synchronous_exports + @exec_exports).uniq.each do |e| tasks[e] end
     end
   end
 end

data/lib/rbbt-util.rb

@@ -20,7 +20,7 @@ require_relative 'rbbt/tsv'
 require_relative 'rbbt/workflow'
 
 Persist.cache_dir     = Rbbt.var.cache.persistence
-FileCache.cachedir    = Rbbt.var.cache.filecache.find :user
-TmpFile.tmpdir        = Rbbt.tmp.find :user
+FileCache.cachedir    = Rbbt.var.cache.filecache.find
+TmpFile.tmpdir        = Rbbt.tmp.find
 Resource.default_resource = Rbbt
 

data/python/rbbt/__init__.py

@@ -1,22 +1,29 @@
-import warnings
 import sys
 import os
 import subprocess
+import tempfile
+import shutil
+import pandas
+import numpy
 
-def cmd(cmd = None):
+
+def cmd(cmd=None):
     if cmd is None:
         print("Rbbt")
     else:
         return subprocess.run('rbbt_exec.rb', input=cmd.encode('utf-8'), capture_output=True).stdout.decode()
 
+
 def libdir():
-    return rbbt('puts Rbbt.find(:lib)').rstrip()
+    return cmd('puts Rbbt.find(:lib)').rstrip()
+
 
 def add_libdir():
     pythondir = os.path.join(libdir(), 'python')
     sys.path.insert(0, pythondir)
 
-def path(subdir = None, base_dir = None):
+
+def path(subdir=None, base_dir=None):
     from pathlib import Path
     import os
 
@@ -144,4 +151,71 @@ def save_tsv(filename, df, key=None):
     key = "#" + key
     df.to_csv(filename, sep="\t", index_label=key)
 
+def save_job_inputs(data):
+    temp_dir = tempfile.mkdtemp()  # Create a temporary directory
+
+    for name, value in data.items():
+        file_path = os.path.join(temp_dir, name)
+
+        if isinstance(value, str):
+            file_path += ".txt"
+            with open(file_path, "w") as f:
+                f.write(value)
+
+        elif isinstance(value, (bool)):
+            with open(file_path, "w") as f:
+                if value:
+                    f.write('true')
+                else:
+                    f.write('false')
+
+        elif isinstance(value, (int, float)):
+            with open(file_path, "w") as f:
+                f.write(str(value))
+
+        elif isinstance(value, pandas.DataFrame):
+            file_path += ".tsv"
+            save_tsv(file_path, value)
 
+        elif isinstance(value, numpy.ndarray) or isinstance(value, list):
+            file_path += ".list"
+            with open(file_path, "w") as f:
+                f.write("\n".join(value))
+
+        else:
+            raise TypeError(f"Unsupported data type for argument '{name}': {type(value)}")
+
+    return temp_dir
+
+
+def run_job(workflow, task, name='Default', fork=False, clean=False, **kwargs):
+    inputs_dir = save_job_inputs(kwargs)
+    cmd = ['rbbt', 'workflow', 'task', workflow, task, '--jobname', name, '--load_inputs', inputs_dir, '--nocolor']
+
+    if fork:
+        cmd.append('--fork')
+        cmd.append('--detach')
+
+    if clean:
+        if clean == 'recursive':
+            cmd.append('--recursive_clean')
+        else:
+            cmd.append('--clean')
+
+    proc = subprocess.run(
+        cmd,
+        capture_output=True,  # Capture both stdout and stderr
+        text=True  # Automatically decode outputs to strings
+        )
+    shutil.rmtree(inputs_dir)
+    if proc.returncode != 0:
+        output = proc.stderr.strip()
+        if output == '' :
+            output = proc.stdout.strip()
+        raise RuntimeError(output)  # Raise error with cleaned stderr content
+    return proc.stdout.strip()
+
+if __name__ == "__main__":
+    import json
+    res = run_job('Baking', 'bake_muffin_tray', 'test', add_blueberries=True, fork=True)
+    print(res)

data/python/rbbt/workflow/remote.py

@@ -0,0 +1,104 @@
+import requests
+import logging
+import json
+from urllib.parse import urlencode, urljoin
+from time import sleep
+import itertools
+
+def request_post(url, params):
+    response = requests.post(url, params)
+    return response
+
+def request_get(url, params):
+    query = urlencode(params)
+    full_url = f"{url}?{query}"
+    response = requests.get(full_url)
+    return response
+
+def get_json(url, params={}):
+    params['_format'] = 'json'
+    response = request_get(url, params)
+    if response.status_code == 200:
+        return json.loads(response.content)  # parse the JSON content from the response
+    else:
+        logging.error("Failed to initialize remote tasks")
+
+def get_raw(url, params={}):
+    params['_format'] = 'raw'
+    response = request_get(url, params)
+    if response.status_code == 200:
+        return response.content  # parse the JSON content from the response
+    else:
+        logging.error("Failed to initialize remote tasks")
+
+def join(url, *subpaths):
+    return url + "/" + "/".join(subpaths)
+
+class RemoteStep:
+    def __init__(self, url):
+        self.url = url
+
+    def info(self):
+        return get_json(join(self.url, 'info'))
+    def status(self):
+        return self.info()['status']
+
+    def done(self):
+        return self.status() == 'done'
+
+    def error(self):
+        return self.status() == 'error' or self.status() == 'aborted'
+
+    def running(self):
+        return not (self.done() or self.error())
+
+    def wait(self, time=1):
+        while self.running():
+            sleep(time)
+
+
+    def raw(self):
+        return get_raw(self.url)
+
+    def json(self):
+        return get_json(self.url)
+
+class RemoteWorkflow:
+    def __init__(self, url):
+        self.url = url
+        self.task_exports = {}
+        self.init_remote_tasks()
+
+    def init_remote_tasks(self):
+        self.task_exports = get_json(self.url)
+        self.tasks = []
+        self.tasks += self.task_exports['asynchronous']
+        self.tasks += self.task_exports['synchronous']
+        self.tasks += self.task_exports['exec']
+
+    def task_info(self, name):
+        return get_json(join(self.url, name, '/info'))
+
+    def job(self, task, **kwargs):
+        kwargs['_format'] = 'jobname'
+        response = request_post(join(self.url, task), kwargs)
+        if response.status_code == 200:
+            jobname = response.content.decode('utf-8')
+            step_url = join(self.url, task, jobname)
+            print(step_url)
+            return RemoteStep(step_url)
+        else:
+            logging.error("Failed to initialize remote tasks")
+
+
+if __name__ == "__main__":
+    wf = RemoteWorkflow('http://localhost:1900/Baking')
+    print(wf.tasks)
+    print(wf.task_info('bake_muffin_tray'))
+
+    step = wf.job('bake_muffin_tray', add_blueberries=True)
+    step.wait()
+    print(step.json())
+
+
+

data/python/rbbt/workflow.py

@@ -0,0 +1,64 @@
+from . import cmd, run_job
+import subprocess
+import json
+import time
+
+def save_inputs(directory, inputs, types):
+    return
+
+class Workflow:
+    def __init__(self, name):
+        self.name = name
+
+    def tasks(self):
+        ruby=f'Workflow.require_workflow("{self.name}").tasks.keys * "\n"'
+        return cmd(ruby).strip().split("\n")
+
+    def task_info(self, name):
+        ruby=f'Workflow.require_workflow("{self.name}").task_info("{name}").to_json'
+        return cmd(ruby)
+
+    def run(self, task, **kwargs):
+        return run_job(self.name, task, **kwargs)
+
+    def fork(self, task, **kwargs):
+        path = run_job(self.name, task, fork=True, **kwargs)
+        return Step(path)
+
+class Step:
+    def __init__(self, path):
+        self.path = path
+        self.info_content = None
+
+    def info(self):
+        if self.info_content:
+            return self.info_content
+        ruby=f'puts Step.load("{self.path}").info.to_json'
+        txt = cmd(ruby)
+        info_content = json.loads(txt)
+        status = info_content["status"]
+        if status == "done" or status == "error" or status == "aborted":
+            self.info_content = info_content
+        return info_content
+
+    def status(self):
+        return self.info()["status"]
+
+    def done(self):
+        return self.status() == 'done'
+
+    def error(self):
+        return self.status() == 'error'
+
+    def aborted(self):
+        return self.status() == 'aborted'
+
+    def join(self):
+        while not (self.done() or self.error() or self.aborted()):
+            time.sleep(1)
+
+    def load(self):
+        ruby=f'puts Step.load("{self.path}").load.to_json'
+        txt = cmd(ruby)
+        return json.loads(txt)
+

data/python/test.py

@@ -0,0 +1,10 @@
+if __name__ == "__main__":
+    import rbbt
+    import rbbt.workflow
+    wf = rbbt.workflow.Workflow('Baking')
+    step = wf.fork('bake_muffin_tray', add_blueberries=True, clean='recursive')
+    step.join()
+    print(step.load())
+
+
+

data/share/rbbt_commands/workflow/retry

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'rbbt/workflow'
+
+require 'rbbt-util'
+require 'rbbt-util'
+require 'rbbt/util/simpleopt'
+
+$0 = "rbbt #{$previous_commands*""} #{ File.basename(__FILE__) }" if $previous_commands
+
+options = SOPT.setup <<EOF
+Retry a failed job
+
+$ rbbt workflow retry <job-path>
+
+Does not retry if job is done unless clean is specified
+
+-h--help Help
+-cl--clean Clean the job
+-rcl--recursive_clean Recursively clean the job
+EOF
+
+SOPT.usage if options[:help]
+
+file = ARGV.shift
+def get_step(file)
+  file = file.sub(/\.(info|files)/,'')
+  step = Workflow.load_step file
+  step
+end
+
+step = get_step(file)
+inputs = step.recursive_inputs
+
+step.clean if options[:clean]
+step.recursive_clean if options[:recursive_clean]
+
+if ! step.done?
+  wf = Workflow.require_workflow step.workflow
+  job = wf.job(step.task_name, step.clean_name, inputs.to_hash)
+  job.run
+end
+

data/share/rbbt_commands/workflow/server

@@ -140,7 +140,7 @@ TmpFile.with_file do |app_dir|
 
       begin
         Rack::Server.start(options)
-      rescue LoadError
+      rescue LoadError, Exception
         require 'rackup'
 
         begin

data/share/rbbt_commands/workflow/task

@@ -535,12 +535,14 @@ begin
     end
   end
 
-  if do_fork
+  if do_fork || detach
     ENV["SCOUT_NO_PROGRESS"] = "true"
     if detach
       job.fork
       Process.detach job.pid if job.pid
-      puts Log.color(:magenta, "Issued: ") + Log.color(:magenta, job.pid ? job.pid.to_s : 'no pid') + ' -- ' + job.path
+      Log.info(Log.color(:magenta, "Issued: ") + Log.color(:magenta, job.pid ? job.pid.to_s : 'no pid') + ' -- ' + job.path)
+      puts job.path
+
       exit 0
     end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rbbt-util
 version: !ruby/object:Gem::Version
-  version: 6.0.3
+  version: 6.0.4
 platform: ruby
 authors:
 - Miguel Vazquez
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-13 00:00:00.000000000 Z
+date: 2025-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: scout-gear
@@ -376,6 +375,9 @@ files:
 - lib/rbbt/workflow/util/provenance.rb
 - lib/rbbt/workflow/util/trace.rb
 - python/rbbt/__init__.py
+- python/rbbt/workflow.py
+- python/rbbt/workflow/remote.py
+- python/test.py
 - share/Rlib/plot.R
 - share/Rlib/svg.R
 - share/Rlib/util.R
@@ -488,6 +490,7 @@ files:
 - share/rbbt_commands/workflow/remote/add
 - share/rbbt_commands/workflow/remote/list
 - share/rbbt_commands/workflow/remote/remove
+- share/rbbt_commands/workflow/retry
 - share/rbbt_commands/workflow/server
 - share/rbbt_commands/workflow/task
 - share/rbbt_commands/workflow/trace
@@ -500,7 +503,6 @@ homepage: http://github.com/mikisvaz/rbbt-util
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -515,8 +517,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key: 
+rubygems_version: 3.6.5
 specification_version: 4
 summary: Utilities for the Ruby Bioinformatics Toolkit (rbbt)
 test_files: []