added Videobox client

Author: matryer

textbox/textbox_test.go

@@ -25,8 +25,8 @@ func TestInfo(t *testing.T) {
 		}`)
 	}))
 	defer srv.Close()
-	nb := textbox.New(srv.URL)
-	info, err := nb.Info()
+	b := textbox.New(srv.URL)
+	info, err := b.Info()
 	is.NoErr(err)
 	is.Equal(info.Name, "textbox")
 	is.Equal(info.Version, 1)

videobox/videobox.go

@@ -0,0 +1,80 @@
+package videobox
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/machinebox/sdk-go/x/boxutil"
+	"github.com/pkg/errors"
+)
+
+// Video represents a video.
+type Video struct {
+	ID                          string      `json:"id"`
+	Status                      VideoStatus `json:"status"`
+	DownloadTotal               int64       `json:"downloadTotal,omitempty"`
+	DownloadComplete            int64       `json:"downloadComplete,omitempty"`
+	DownloadEstimatedCompletion *time.Time  `json:"downloadCompleteEstimate,omitempty"`
+	TotalFrames                 int         `json:"framesCount,omitempty"`
+	FramesComplete              int         `json:"framesComplete"`
+	LastFrameBase64             string      `json:"lastFrameBase64,omitempty"`
+	MillisecondsComplete        int         `json:"millisecondsComplete"`
+	Expires                     *time.Time  `json:"expires,omitempty"`
+}
+
+// Client is an HTTP client that can make requests to the box.
+type Client struct {
+	addr string
+
+	// HTTPClient is the http.Client that will be used to
+	// make requests.
+	HTTPClient *http.Client
+}
+
+// New makes a new Client.
+func New(addr string) *Client {
+	return &Client{
+		addr: addr,
+		HTTPClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+	}
+}
+
+// Info gets the details about the box.
+func (c *Client) Info() (*boxutil.Info, error) {
+	var info boxutil.Info
+	u, err := url.Parse(c.addr + "/info")
+	if err != nil {
+		return nil, err
+	}
+	if !u.IsAbs() {
+		return nil, errors.New("box address must be absolute")
+	}
+	req, err := http.NewRequest("GET", u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/json; charset=utf-8")
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, errors.New(resp.Status)
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
+		return nil, err
+	}
+	return &info, nil
+}
+
+// ErrVideobox represents an error from facebox.
+type ErrVideobox string
+
+func (e ErrVideobox) Error() string {
+	return "videobox: " + string(e)
+}

videobox/videobox_check.go

@@ -0,0 +1,234 @@
+package videobox
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// Check starts processing the video in the Reader.
+// Videobox is asynchronous, you must use Status to check when a
+// video processing operation has completed before using Results to
+// get the results.
+func (c *Client) Check(video io.Reader, options *CheckOptions) (*Video, error) {
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	fw, err := w.CreateFormFile("file", "image.dat")
+	if err != nil {
+		return nil, err
+	}
+	_, err = io.Copy(fw, video)
+	if err != nil {
+		return nil, err
+	}
+	if err := options.apply(w.WriteField); err != nil {
+		return nil, errors.Wrap(err, "setting options")
+	}
+	if err = w.Close(); err != nil {
+		return nil, err
+	}
+	u, err := url.Parse(c.addr + "/videobox/check")
+	if err != nil {
+		return nil, err
+	}
+	if !u.IsAbs() {
+		return nil, errors.New("box address must be absolute")
+	}
+	req, err := http.NewRequest("POST", u.String(), &buf)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/json; charset=utf-8")
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, errors.New(resp.Status)
+	}
+	return c.parseCheckResponse(resp.Body)
+}
+
+// CheckURL starts processing the video at the specified URL.
+// See Check for more information.
+func (c *Client) CheckURL(videoURL *url.URL, options *CheckOptions) (*Video, error) {
+	u, err := url.Parse(c.addr + "/videobox/check")
+	if err != nil {
+		return nil, err
+	}
+	if !u.IsAbs() {
+		return nil, errors.New("box address must be absolute")
+	}
+	if !videoURL.IsAbs() {
+		return nil, errors.New("url must be absolute")
+	}
+	form := url.Values{}
+	form.Set("url", videoURL.String())
+	formset := func(key, value string) error {
+		form.Set(key, value)
+		return nil
+	}
+	if err := options.apply(formset); err != nil {
+		return nil, errors.Wrap(err, "setting options")
+	}
+	req, err := http.NewRequest("POST", u.String(), strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Accept", "application/json; charset=utf-8")
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, errors.New(resp.Status)
+	}
+	return c.parseCheckResponse(resp.Body)
+}
+
+// CheckBase64 starts processing the video from the base64 encoded data string.
+// See Check for more information.
+func (c *Client) CheckBase64(data string, options *CheckOptions) (*Video, error) {
+	u, err := url.Parse(c.addr + "/videobox/check")
+	if err != nil {
+		return nil, err
+	}
+	if !u.IsAbs() {
+		return nil, errors.New("box address must be absolute")
+	}
+	form := url.Values{}
+	form.Set("base64", data)
+	formset := func(key, value string) error {
+		form.Set(key, value)
+		return nil
+	}
+	if err := options.apply(formset); err != nil {
+		return nil, errors.Wrap(err, "setting options")
+	}
+	req, err := http.NewRequest("POST", u.String(), strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Accept", "application/json; charset=utf-8")
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, errors.New(resp.Status)
+	}
+	return c.parseCheckResponse(resp.Body)
+}
+
+// CheckOptions are additional options that control
+// the behaviour of Videobox when processing videos.
+type CheckOptions struct {
+	fields map[string]string
+}
+
+// NewCheckOptions makes a new CheckOptions object.
+func NewCheckOptions() *CheckOptions {
+	return &CheckOptions{
+		fields: make(map[string]string),
+	}
+}
+
+// ResultsDuration sets the duration results should be kept in Videobox
+// before being garbage collected.
+func (o *CheckOptions) ResultsDuration(duration time.Duration) {
+	o.fields["resultsDuration"] = duration.String()
+}
+
+// SkipFrames sets the number of frames to skip between extractions.
+func (o *CheckOptions) SkipFrames(frames int) {
+	o.fields["skipframes"] = strconv.Itoa(frames)
+}
+
+// SkipSeconds sets the number of seconds to skip between frame extractions.
+func (o *CheckOptions) SkipSeconds(seconds int) {
+	o.fields["skipseconds"] = strconv.Itoa(seconds)
+}
+
+// FrameWidth sets the width of the frame to extract.
+func (o *CheckOptions) FrameWidth(width int) {
+	o.fields["frameWidth"] = strconv.Itoa(width)
+}
+
+// FrameHeight sets the height of the frame to extract.
+func (o *CheckOptions) FrameHeight(height int) {
+	o.fields["frameHeight"] = strconv.Itoa(height)
+}
+
+// FaceboxThreshold sets the minimum confidence threshold of Facebox
+// matches required for it to be included in the results.
+func (o *CheckOptions) FaceboxThreshold(v float64) {
+	o.fields["faceboxThreshold"] = strconv.FormatFloat(v, 'f', -1, 64)
+}
+
+// TagboxIncludeAll includes all tags in the results.
+func (o *CheckOptions) TagboxIncludeAll() {
+	o.fields["tagboxInclude"] = "all"
+}
+
+// TagboxIncludeCustom includes only custom tags in the results.
+func (o *CheckOptions) TagboxIncludeCustom() {
+	o.fields["tagboxInclude"] = "custom"
+}
+
+// TagboxThreshold sets the minimum confidence threshold of Tagbox
+// matches required for it to be included in the results.
+func (o *CheckOptions) TagboxThreshold(v float64) {
+	o.fields["tagboxThreshold"] = strconv.FormatFloat(v, 'f', -1, 64)
+}
+
+// NudeboxThreshold sets the minimum confidence threshold of Nudebox
+// matches required for it to be included in the results.
+func (o *CheckOptions) NudeboxThreshold(v float64) {
+	o.fields["nudeboxThreshold"] = strconv.FormatFloat(v, 'f', -1, 64)
+}
+
+// apply calls writeField for each field.
+// If o is nil, apply is noop.
+func (o *CheckOptions) apply(writeField func(key, value string) error) error {
+	if o == nil {
+		return nil
+	}
+	for k, v := range o.fields {
+		if err := writeField(k, v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *Client) parseCheckResponse(r io.Reader) (*Video, error) {
+	var checkResponse struct {
+		Success bool
+		Error   string
+		ID      string
+	}
+	if err := json.NewDecoder(r).Decode(&checkResponse); err != nil {
+		return nil, errors.Wrap(err, "decoding response")
+	}
+	if !checkResponse.Success {
+		return nil, ErrVideobox(checkResponse.Error)
+	}
+	v := &Video{
+		ID: checkResponse.ID,
+	}
+	return v, nil
+}