Tech preview: new AI Robots for enhanced media processing

{
  "steps": {
    ":original": {
      "robot": "/upload/handle"
    },
    "described": {
      "use": ":original",
      "robot": "/image/describe",
      "provider": "aws",
      "format": "meta",
      "granularity": "list",
      "result": true
    },
    "filtered": {
      "result": true,
      "use": "described",
      "robot": "/file/filter",
      "accepts": [["${file.meta.descriptions}", "includes", "Building"]]
    },
    "exported": {
      "use": "filtered",
      "robot": "/s3/store",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}

# Prerequisites: brew install curl jq || sudo apt install curl jq
# To avoid tampering, use Signature Authentication
echo '{
  "template_id": undefined,
  "auth": {
    "key": "YOUR_TRANSLOADIT_KEY"
  },
  "steps": {
    ":original": {
      "robot": "/upload/handle"
    },
    "described": {
      "use": ":original",
      "robot": "/image/describe",
      "provider": "aws",
      "format": "meta",
      "granularity": "list",
      "result": true
    },
    "filtered": {
      "result": true,
      "use": "described",
      "robot": "/file/filter",
      "accepts": [["${file.meta.descriptions}", "includes", "Building"]]
    },
    "exported": {
      "use": "filtered",
      "robot": "/s3/store",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}' | curl \
    --request POST \
    --form 'params=<-' \
    --form myfile1=@./prinsengracht.jpg \
    --form myfile2=@./chameleon.jpg \
    https://api2.transloadit.com/assemblies | jq

// Install via Swift Package Manager:
// dependencies: [
//   .package(url: "https://github.com/transloadit/TransloaditKit", .upToNextMajor(from: "3.0.0"))
// ]
// Or via CocoaPods:
// pod 'Transloadit', '~> 3.0.0'
// Auth
let credentials = Credentials(key: "YOUR_TRANSLOADIT_KEY")
// Init
let transloadit = Transloadit(credentials: credentials, session: "URLSession.shared")
// Add files to upload
let filesToUpload: [URL] = ...
// Execute
let assembly = transloadit.assembly(steps: [_originalStep, describedStep, filteredStep, exportedStep], andUpload: filesToUpload) { result in
  switch result {
  case .success(let assembly):
    print("Retrieved (assembly)")
  case .failure(let error):
    print("Assembly error (error)")
  }
}.pollAssemblyStatus { result in
  switch result {
  case .success(let assemblyStatus):
    print("Received assemblystatus (assemblyStatus)")
  case .failure(let error):
    print("Caught polling error (error)")
  }

// yarn add transloadit || npm i transloadit
// Import
const Transloadit = require('transloadit')
const main = async () => {
  // Init
  const transloadit = new Transloadit({
    authKey: 'YOUR_TRANSLOADIT_KEY',
    authSecret: 'MY_TRANSLOADIT_SECRET',
  })
// Set Encoding Instructions
  const options = {
    files: {
      myfile_1: './prinsengracht.jpg',
      myfile_2: './chameleon.jpg',
    },
    params: {
      steps: {
        ':original': {
          robot: '/upload/handle',
        },
        described: {
          use: ':original',
          robot: '/image/describe',
          provider: 'aws',
          format: 'meta',
          granularity: 'list',
          result: true,
        },
        filtered: {
          result: true,
          use: 'described',
          robot: '/file/filter',
          accepts: [['${file.meta.descriptions}', 'includes', 'Building']],
        },
        exported: {
          use: 'filtered',
          robot: '/s3/store',
          credentials: 'YOUR_AWS_CREDENTIALS',
          url_prefix: 'https://demos.transloadit.com/',
        },
      },
    },
  }
// Execute
  const result = await transloadit.createAssembly(options)
// Show results
  console.log({ result })
}
main().catch(console.error)

# [sudo] npm install transloadify -g
# Auth
export TRANSLOADIT_KEY="YOUR_TRANSLOADIT_KEY"
# Save Encoding Instructions
echo '{
  "steps": {
    ":original": {
      "robot": "/upload/handle"
    },
    "described": {
      "use": ":original",
      "robot": "/image/describe",
      "provider": "aws",
      "format": "meta",
      "granularity": "list",
      "result": true
    },
    "filtered": {
      "result": true,
      "use": "described",
      "robot": "/file/filter",
      "accepts": [["${file.meta.descriptions}", "includes", "Building"]]
    },
    "exported": {
      "use": "filtered",
      "robot": "/s3/store",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}' > ./steps.json
# Execute
transloadify 

  --input "prinsengracht.jpg" 

  --input "chameleon.jpg" 

  --steps "./steps.json" 

  --output "./output.example"

// composer require transloadit/php-sdk
use transloadit\Transloadit;
$transloadit = new Transloadit([
  "key" => "YOUR_TRANSLOADIT_KEY",
  "secret" => "MY_TRANSLOADIT_SECRET",
]);
// Start the Assembly
$response = $transloadit->createAssembly([
  "files" => ["prinsengracht.jpg", "chameleon.jpg"],
  "params" => [
    "steps" => [
      ":original" => [
        "robot" => "/upload/handle",
      ],
      "described" => [
        "use" => ":original",
        "robot" => "/image/describe",
        "provider" => "aws",
        "format" => "meta",
        "granularity" => "list",
        "result" => true,
      ],
      "filtered" => [
        "result" => true,
        "use" => "described",
        "robot" => "/file/filter",
        "accepts" => [["${file.meta.descriptions}", "includes", "Building"]],
      ],
      "exported" => [
        "use" => "filtered",
        "robot" => "/s3/store",
        "credentials" => "YOUR_AWS_CREDENTIALS",
        "url_prefix" => "https://demos.transloadit.com/",
      ],
    ],
  ],
]);

# gem install transloadit
# $ irb -rubygems
# >> require 'transloadit'
# => true
transloadit = Transloadit.new([
  :key => "YOUR_TRANSLOADIT_KEY",
])
# Set Encoding Instructions
_original = transloadit.step(":original", "/upload/handle", {})
described = transloadit.step("described", "/image/describe", [
  :use => ":original",
  :provider => "aws",
  :format => "meta",
  :granularity => "list",
  :result => true
])
filtered = transloadit.step("filtered", "/file/filter", [
  :result => true,
  :use => "described",
  :accepts => [["${file.meta.descriptions}", "includes", "Building"]]
])
exported = transloadit.step("exported", "/s3/store", [
  :use => "filtered",
  :credentials => "YOUR_AWS_CREDENTIALS",
  :url_prefix => "https://demos.transloadit.com/"
])
transloadit.assembly([
  :steps => [_original, described, filtered, exported]
])
# Add files to upload
files = []
files.push("prinsengracht.jpg")
files.push("chameleon.jpg")
# Start the Assembly
response = assembly.create! *files
until response.finished?
  sleep 1; response.reload!
end
if !response.error?
  # handle success
end

# pip install pytransloadit
from transloadit import client
tl = client.Transloadit('YOUR_TRANSLOADIT_KEY', 'MY_TRANSLOADIT_SECRET')
assembly = tl.new_assembly()
# Set Encoding Instructions
assembly.add_step(":original", "/upload/handle", {})
assembly.add_step("described", "/image/describe", {
  'use': ':original',
  'provider': 'aws',
  'format': 'meta',
  'granularity': 'list',
  'result': True
})
assembly.add_step("filtered", "/file/filter", {
  'result': True,
  'use': 'described',
  'accepts': [['${file.meta.descriptions}', 'includes', 'Building']]
})
assembly.add_step("exported", "/s3/store", {
  'use': 'filtered',
  'credentials': 'YOUR_AWS_CREDENTIALS',
  'url_prefix': 'https://demos.transloadit.com/'
})
# Add files to upload
assembly.add_file(open('prinsengracht.jpg', 'rb'))
assembly.add_file(open('chameleon.jpg', 'rb'))
# Start the Assembly
assembly_response = assembly.create(retries=5, wait=True)
print(assembly_response.data.get('assembly_ssl_url'))
# or:
print(assembly_response.data['assembly_ssl_url'])

// go get gopkg.in/transloadit/go-sdk.v1
package main
import (
  "context"
  "fmt"
  "github.com/transloadit/go-sdk"
)
func main() {
  // Create client
  options := transloadit.DefaultConfig
  options.AuthKey = "YOUR_TRANSLOADIT_KEY"
  options.AuthSecret = "MY_TRANSLOADIT_SECRET"
  client := transloadit.NewClient(options)
  
  // Initialize new Assembly
  assembly := transloadit.NewAssembly()
  
  // Set Encoding Instructions
  assembly.AddStep(":original", map[string]interface{}{
    "robot": "/upload/handle",
  })
  
  assembly.AddStep("described", map[string]interface{}{
    "use": ":original",
    "robot": "/image/describe",
    "provider": "aws",
    "format": "meta",
    "granularity": "list",
    "result": true,
  })
  
  assembly.AddStep("filtered", map[string]interface{}{
    "result": true,
    "use": "described",
    "robot": "/file/filter",
    "accepts": [["${file.meta.descriptions}", "includes", "Building"]],
  })
  
  assembly.AddStep("exported", map[string]interface{}{
    "use": "filtered",
    "robot": "/s3/store",
    "credentials": "YOUR_AWS_CREDENTIALS",
    "url_prefix": "https://demos.transloadit.com/",
  })
  
  // Add files to upload
  assembly.AddFile("prinsengracht.jpg"))
  assembly.AddFile("chameleon.jpg"))
  
  // Start the Assembly
  info, err := client.StartAssembly(context.Background(), assembly)
  if err != nil {
    panic(err)
  }
  
  // All files have now been uploaded and the Assembly has started but no
  // results are available yet since the conversion has not finished.
  // WaitForAssembly provides functionality for polling until the Assembly
  // has ended.
  info, err = client.WaitForAssembly(context.Background(), info)
  if err != nil {
    panic(err)
  }
  
  fmt.Printf("You can check some results at: ")
  fmt.Printf("  - %s\n", info.Results[":original"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["described"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["filtered"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["exported"][0].SSLURL)
}

// implementation 'com.transloadit.sdk:transloadit:1.0.0
import com.transloadit.sdk.Assembly;
import com.transloadit.sdk.Transloadit;
import com.transloadit.sdk.exceptions.LocalOperationException;
import com.transloadit.sdk.exceptions.RequestException;
import com.transloadit.sdk.response.AssemblyResponse;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
public class Main {
  public static void main(String[] args) {
    // Initialize the Transloadit client
    Transloadit transloadit = new Transloadit("YOUR_TRANSLOADIT_KEY", "MY_TRANSLOADIT_SECRET");
    
    Assembly assembly = transloadit.newAssembly();
    
    // Set Encoding Instructions
    Map<String, Object> _originalStepOptions = new HashMap();
    assembly.addStep(":original", "/upload/handle", _originalStepOptions);
    
    Map<String, Object> describedStepOptions = new HashMap();
    describedStepOptions.put("use", ":original");
    describedStepOptions.put("provider", "aws");
    describedStepOptions.put("format", "meta");
    describedStepOptions.put("granularity", "list");
    describedStepOptions.put("result", true);
    assembly.addStep("described", "/image/describe", describedStepOptions);
    
    Map<String, Object> filteredStepOptions = new HashMap();
    filteredStepOptions.put("result", true);
    filteredStepOptions.put("use", "described");
    filteredStepOptions.put("accepts", new String[] { new String[] { "${file.meta.descriptions}", "includes", "Building" } });
    assembly.addStep("filtered", "/file/filter", filteredStepOptions);
    
    Map<String, Object> exportedStepOptions = new HashMap();
    exportedStepOptions.put("use", "filtered");
    exportedStepOptions.put("credentials", "YOUR_AWS_CREDENTIALS");
    exportedStepOptions.put("url_prefix", "https://demos.transloadit.com/");
    assembly.addStep("exported", "/s3/store", exportedStepOptions);
    
    // Add files to upload
    assembly.addFile(new File("prinsengracht.jpg"));
    assembly.addFile(new File("chameleon.jpg"));
    
    // Start the Assembly
    try {
      AssemblyResponse response = assembly.save();
    
      // Wait for Assembly to finish executing
      while (!response.isFinished()) {
        response = transloadit.getAssemblyByUrl(response.getSslUrl());
      }
    
      System.out.println(response.getId());
      System.out.println(response.getUrl());
      System.out.println(response.json());
    } catch (RequestException | LocalOperationException e) {
      // Handle exception here
    }
  }
}