xapixctl 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175a3c54493e14738757b5eb95ef1da9724b961f460d1ac5dfb17ea6eb696507
-  data.tar.gz: 0a79951ab81a2b69d0087161191097cf24b01e2282887d03b12e8f32527d3707
+  metadata.gz: 4ba3cb0a95f481dfd6568282c75d0bc4a2db36a03c4b8a177401deac61b04eaa
+  data.tar.gz: f5cd613fdcb2c9a204b224b6504348c4840fe45fd3506bea904bb26d5367793a
 SHA512:
-  metadata.gz: 040c017fb340670f8751a45c5b9c0c659cd814bb712cc74fb40e368f714fb1b80759d9c4387cbbb19999cfd512fc389a082168cde33f67cc1fd9fa0fb17b42f3
-  data.tar.gz: 1bdbbbb3da472ade7b520cfebc284ebebdeb871ee77c3bafa5fb22789bf4c0057d4dc7ff116ee3c0d611dbd692d99a96ac168ffa8824be006b22b124c7e98bf7
+  metadata.gz: c0635abac3da2424e0109306eec1795dac8ae2cf9cb81aa4f8769ef397f5e70f4b5db7095b2820f0a49f7902d2d3e75df86b2128622fdaa10bb3082dea38ddab
+  data.tar.gz: f14855a202d934303acf771987686dcf395c0842a870a309283bbd080c1ebd32c0c1178e1a0df2256352c575920e4116010953a4e6d2a8833e178f27838f5e85

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    xapixctl (1.2.1)
+    xapixctl (1.2.2)
       activesupport (>= 5.2.3, < 6.0.0)
       rest-client (>= 2.1.0, < 3.0.0)
       thor (>= 1.0.0, < 1.2.0)

data/lib/xapixctl/cli.rb

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
 require 'xapixctl/base_cli'
+require 'xapixctl/connector_cli'
 require 'xapixctl/preview_cli'
 require 'xapixctl/sync_cli'
+require 'xapixctl/titan_cli'
 
 module Xapixctl
   class Cli < BaseCli
+    desc "connectors SUBCOMMAND ...ARGS", "Commands for Connector resources"
+    subcommand "connectors", ConnectorCli
+
     desc "preview SUBCOMMAND ...ARGS", "Request preview for resources"
     subcommand "preview", PreviewCli
 
     desc "sync SUBCOMMAND ...ARGS", "Sync resources"
     subcommand "sync", SyncCli
 
+    desc "titan SUBCOMMAND ...ARGS", "Tools for ML model deployments and service generation", hide: true
+    subcommand "titan", TitanCli
+
     option :format, aliases: "-f", default: 'text', enum: ['text', 'yaml', 'json'], desc: "Output format"
     desc "get TYPE [ID]", "retrieve either all resources of given TYPE or just the resource of given TYPE and ID"
     long_desc <<-LONGDESC

data/lib/xapixctl/connector_cli.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'xapixctl/base_cli'
+
+module Xapixctl
+  class ConnectorCli < BaseCli
+    option :schema_import, desc: "Resource id of an existing Schema import"
+    desc "import SPECFILE", "Create HTTP Connectors from Swagger / OpenAPI or SOAP WSDL files"
+    long_desc <<-LONGDESC
+      `xapixctl connectors import SPECFILE` will create HTTP Connectors from the given Swagger / OpenAPI or SOAP WSDL file.
+
+      Examples:
+      \x5> $ xapixctl connectors import ./swagger.json -p xapix/some-project
+      \x5> $ xapixctl connectors import ./swagger.json -p xapix/some-project --schema-import=existing-schema
+    LONGDESC
+    def import(spec_filename)
+      path = Pathname.new(spec_filename)
+      unless path.file? && path.readable?
+        warn "Cannot read #{path}, please check file exists and is readable"
+        exit 1
+      end
+      if options[:schema_import]
+        puts "uploading to update schema import '#{options[:schema_import]}': #{spec_filename}..."
+        result = prj_connection.update_schema_import(options[:schema_import], spec_filename)
+        puts "updated #{result.dig('resource', 'kind')} #{result.dig('resource', 'id')}"
+      else
+        puts "uploading as new import: #{spec_filename}..."
+        result = prj_connection.add_schema_import(spec_filename)
+        puts "created #{result.dig('resource', 'kind')} #{result.dig('resource', 'id')}"
+      end
+
+      [['issues', 'import'], ['validation_issues', 'validation']].each do |key, name|
+        issues = result.dig('schema_import', 'report', key)
+        if issues.any?
+          puts "\n#{name} issues:"
+          issues.each { |issue| puts " - #{issue}" }
+        end
+      end
+
+      updated_resources = result.dig('schema_import', 'updated_resources')
+      if updated_resources.any?
+        puts "\nconnectors:"
+        updated_resources.each { |resource| puts " - #{resource['kind']} #{resource['id']}" }
+      else
+        puts "\nno connectors created/updated."
+      end
+    end
+  end
+end

data/lib/xapixctl/phoenix_client/project_connection.rb

@@ -76,6 +76,18 @@ module Xapixctl
           run { @client[data_source_preview_path(data_source_id)].post(preview_data.to_json, content_type: :json) }
       end
 
+      def add_schema_import(spec_filename, &block)
+        spec_data = { schema_import: { file: File.new(spec_filename, 'r') } }
+        result_handler(block).
+          run { @client[schema_imports_path].post(spec_data) }
+      end
+
+      def update_schema_import(schema_import, spec_filename, &block)
+        spec_data = { schema_import: { file: File.new(spec_filename, 'r') } }
+        result_handler(block).
+          run { @client[schema_import_path(schema_import)].patch(spec_data) }
+      end
+
       def pipeline_preview(pipeline_id, format: :hash, &block)
         result_handler(block).
           prepare_data(->(data) { data['pipeline_preview'] }).
@@ -128,6 +140,14 @@ module Xapixctl
         "/projects/#{@org}/#{@project}/onboarding/data_sources/#{id}/preview"
       end
 
+      def schema_imports_path
+        "/projects/#{@org}/#{@project}/onboarding/schema_imports"
+      end
+
+      def schema_import_path(schema_import)
+        "/projects/#{@org}/#{@project}/onboarding/schema_imports/#{schema_import}"
+      end
+
       def resource_path(type, id)
         "/projects/#{@org}/#{@project}/#{translate_type(type)}/#{id}"
       end

data/lib/xapixctl/titan_cli.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'xapixctl/base_cli'
+
+module Xapixctl
+  class TitanCli < BaseCli
+    DEFAULT_METHODS = {
+      "predict" => :predict,
+      "performance" => :performance,
+    }.freeze
+
+    option :schema_import, desc: "Resource id of an existing Schema import"
+    option :data, desc: "JSON encoded data for predict API", default: "[[1,2,3]]"
+    desc "service URL", "build a service for the deployed model"
+    long_desc <<-LONGDESC
+      `xapixctl titan service URL` will build a ML service around a deployed ML model.
+
+      We expect the following of the deployed ML model:
+
+      - There should be a "POST /predict" endpoint. Use --data="JSON" to specify an example dataset the model expects.
+
+      - If there is a "GET /performance" endpoint, it'll be made available. It's expected to return a JSON object with the properties 'accuracy', 'precision', 'recall', and 'min_acc_threshold'.
+
+      Examples:
+      \x5> $ xapixctl titan service https://services.demo.akoios.com/ai-model-name -p xapix/ml-project
+    LONGDESC
+    def service(akoios_url)
+      url = URI.parse(akoios_url)
+      schema = JSON.parse(RestClient.get(File.join(url.to_s, 'spec'), params: { host: url.hostname }, headers: { accept: :json }))
+      patch_schema(schema)
+      connector_refs = import_swagger(File.basename(url.path), schema)
+      say "\n== Onboarding Connectors", :bold
+      connectors = match_connectors_to_action(connector_refs)
+      say "\n== Building Service", :bold
+      service_doc = build_service(schema.dig('info', 'title'), connectors)
+      res = prj_connection.apply(service_doc)
+      say "\ncreated / updated service #{res.first}"
+    end
+
+    private
+
+    def patch_schema(schema)
+      predict_schema = schema.dig('paths', '/predict', 'post')
+      if predict_schema
+        predict_data = JSON.parse(options[:data]) rescue {}
+        predict_schema['operationId'] = 'predict'
+        predict_schema['parameters'].each do |param|
+          if param['name'] == 'json' && param['in'] == 'body'
+            param['schema']['properties'] = { "data" => extract_schema(predict_data) }
+            param['schema']['example'] = { "data" => predict_data }
+          end
+        end
+      end
+
+      performane_schema = schema.dig('paths', '/performance', 'get')
+      if performane_schema
+        performane_schema['operationId'] = 'performance'
+      end
+    end
+
+    def import_swagger(filename, schema)
+      Tempfile.create([filename, '.json']) do |f|
+        f.write(schema.to_json)
+        f.rewind
+
+        if options[:schema_import]
+          result = prj_connection.update_schema_import(options[:schema_import], f)
+          say "updated #{result.dig('resource', 'kind')} #{result.dig('resource', 'id')}"
+        else
+          result = prj_connection.add_schema_import(f)
+          say "created #{result.dig('resource', 'kind')} #{result.dig('resource', 'id')}"
+        end
+        result.dig('schema_import', 'updated_resources')
+      end
+    end
+
+    def match_connectors_to_action(connector_refs)
+      connector_refs.map do |connector_ref|
+        connector = prj_connection.resource(connector_ref['kind'], connector_ref['id'])
+        action = DEFAULT_METHODS[connector.dig('definition', 'name')]
+        say "\n#{connector['kind']} #{connector.dig('definition', 'name')} -> "
+        if action
+          say "#{action} action"
+          [action, update_connector_with_preview(connector)]
+        else
+          say "no action type detected, ignoring"
+          nil
+        end
+      end.compact
+    end
+
+    def update_connector_with_preview(connector)
+      say "fetching preview for #{connector['kind']} #{connector.dig('definition', 'name')}..."
+      preview_details = prj_connection.data_source_preview(connector.dig('metadata', 'id'))
+      preview = preview_details.dig('preview', 'sample')
+      say "got a #{preview['status']} response: #{preview['body']}"
+      if preview['status'] != 200
+        say "unexpected status, please check data or model"
+      elsif yes?("Does this look alright?", :bold)
+        res = prj_connection.accept_data_source_preview(connector.dig('metadata', 'id'))
+        return res.dig('data_source', 'resource_description')
+      end
+      connector
+    end
+
+    def extract_schema(data_sample)
+      case data_sample
+      when Array
+        { type: 'array', items: extract_schema(data_sample[0]) }
+      when Hash
+        { type: 'object', properties: data_sample.transform_values { |v| extract_schema(v) } }
+      when Numeric
+        { type: 'number' }
+      else
+        {}
+      end
+    end
+
+    def build_service(title, connectors)
+      {
+        version: 'v1',
+        kind: 'Service',
+        metadata: { id: title.parameterize },
+        definition: {
+          name: title.humanize,
+          actions: connectors.map { |action, connector| build_service_action(action, connector) }
+        }
+      }
+    end
+
+    def build_service_action(action_type, connector)
+      {
+        name: action_type,
+        parameter_schema: parameter_schema(action_type, connector),
+        result_schema: result_schema(action_type),
+        pipeline: { units: pipeline_units(action_type, connector) }
+      }
+    end
+
+    def parameter_schema(action_type, connector)
+      case action_type
+      when :predict
+        { type: 'object', properties: {
+          data: connector.dig('definition', 'parameter_schema', 'properties', 'body', 'properties', 'data'),
+        } }
+      when :performance
+        { type: 'object', properties: {} }
+      end
+    end
+
+    def result_schema(action_type)
+      case action_type
+      when :predict
+        { type: 'object', properties: {
+          prediction: { type: 'object', properties: { percent: { type: 'number' }, raw: { type: 'number' } } },
+          success: { type: 'boolean' },
+          error: { type: 'string' }
+        } }
+      when :performance
+        { type: 'object', properties: {
+          performance: {
+            type: 'object', properties: {
+              accuracy: { type: 'number' },
+              precision: { type: 'number' },
+              recall: { type: 'number' },
+              min_acc_threshold: { type: 'number' }
+            }
+          }
+        } }
+      end
+    end
+
+    def pipeline_units(action_type, connector)
+      case action_type
+      when :predict
+        [entry_unit, predict_unit(connector), predict_result_unit]
+      when :performance
+        [entry_unit, performance_unit(connector), performance_result_unit]
+      end
+    end
+
+    def entry_unit
+      { version: 'v2', kind: 'Unit/Entry',
+        metadata: { id: 'entry' },
+        definition: { name: 'Entry' } }
+    end
+
+    def predict_unit(connector)
+      leafs = extract_leafs(connector.dig('definition', 'parameter_schema', 'properties', 'body'))
+      { version: 'v2', kind: 'Unit/DataSource',
+        metadata: { id: 'predict' },
+        definition: {
+          name: 'Predict',
+          inputs: ['entry'],
+          data_source: connector.dig('metadata', 'id'),
+          formulas: leafs.map { |leaf|
+            { ref: leaf[:node]['$id'], formula: (['', 'entry'] + leaf[:path]).join('.') }
+          }
+        } }
+    end
+
+    def predict_result_unit
+      { version: 'v2', kind: 'Unit/Result',
+        metadata: { id: 'result' },
+        definition: {
+          name: 'Result',
+          inputs: ['predict'],
+          formulas: [{
+            ref: "#prediction.raw",
+            formula: "IF(.predict.status = 200, ROUND(100*coerce.to-float(.predict.body), 2))"
+          }, {
+            ref: "#prediction.percent",
+            formula: "IF(.predict.status = 200, coerce.to-float(.predict.body))"
+          }, {
+            ref: "#success",
+            formula: ".predict.status = 200"
+          }, {
+            ref: "#error",
+            formula: "IF(.predict.status <> 200, 'Model not trained!')"
+          }],
+          parameter_sample: {
+            "prediction" => { "percent" => 51, "raw" => 0.5112131 },
+            "success" => true,
+            "error" => nil
+          }
+        } }
+    end
+
+    def performance_unit(connector)
+      { version: 'v2', kind: 'Unit/DataSource',
+        metadata: { id: 'performance' },
+        definition: {
+          name: 'Performance',
+          inputs: ['entry'],
+          data_source: connector.dig('metadata', 'id')
+        } }
+    end
+
+    def performance_result_unit
+      { version: 'v2', kind: 'Unit/Result',
+        metadata: { id: 'result' },
+        definition: {
+          name: 'Result',
+          inputs: ['performance'],
+          formulas: [{
+            ref: "#performance.recall",
+            formula: "WITH(data, JSON.DECODE(REGEXREPLACE(performance.body, \"'\", \"\\\"\")), .data.recall)"
+          }, {
+            ref: "#performance.accuracy",
+            formula: "WITH(data, JSON.DECODE(REGEXREPLACE(performance.body, \"'\", \"\\\"\")), .data.accuracy)"
+          }, {
+            ref: "#performance.precision",
+            formula: "WITH(data, JSON.DECODE(REGEXREPLACE(performance.body, \"'\", \"\\\"\")), .data.precision)"
+          }, {
+            ref: "#performance.min_acc_threshold",
+            formula: "WITH(data, JSON.DECODE(REGEXREPLACE(performance.body, \"'\", \"\\\"\")), .data.min_acc_threshold)"
+          }],
+          parameter_sample: {
+            "performance" => {
+              "recall" => 0.8184713375796179,
+              "accuracy" => 0.9807847896440129,
+              "precision" => 0.8711864406779661,
+              "min_acc_threshold" => 0.84,
+            }
+          }
+        } }
+    end
+
+    def extract_leafs(schema, current_path = [])
+      return unless schema
+      case schema['type']
+      when 'object'
+        schema['properties'].flat_map { |key, sub_schema| extract_leafs(sub_schema, current_path + [key]) }.compact
+      when 'array'
+        extract_leafs(schema['items'], current_path + [:[]])
+      else
+        { path: current_path, node: schema }
+      end
+    end
+  end
+end

data/lib/xapixctl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Xapixctl
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xapixctl
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Michael Reinsch
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-24 00:00:00.000000000 Z
+date: 2021-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -206,6 +206,7 @@ files:
 - lib/xapixctl.rb
 - lib/xapixctl/base_cli.rb
 - lib/xapixctl/cli.rb
+- lib/xapixctl/connector_cli.rb
 - lib/xapixctl/phoenix_client.rb
 - lib/xapixctl/phoenix_client/connection.rb
 - lib/xapixctl/phoenix_client/organization_connection.rb
@@ -213,6 +214,7 @@ files:
 - lib/xapixctl/phoenix_client/result_handler.rb
 - lib/xapixctl/preview_cli.rb
 - lib/xapixctl/sync_cli.rb
+- lib/xapixctl/titan_cli.rb
 - lib/xapixctl/util.rb
 - lib/xapixctl/version.rb
 - xapixctl.gemspec