simplify display functions and types in preparation for interfaces dedicated to rendering - see issue #166

Author: cosmos72

display.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"image"
 	"io"
 	"io/ioutil"
 	"net/http"
@@ -65,12 +66,15 @@ func read(data interface{}) ([]byte, string) {
 }
 
 func Any(mimeType string, data interface{}) Data {
+	if img, ok := data.(image.Image); ok {
+		return Image(img)
+	}
 	b, s := read(data)
 	if len(mimeType) == 0 {
 		mimeType = http.DetectContentType(b)
 	}
 	d := Data{
-		Data: BundledMIMEData{
+		Data: MIMEMap{
 			"text/plain": s,
 		},
 	}
@@ -80,9 +84,14 @@ func Any(mimeType string, data interface{}) Data {
 	return d
 }
 
+// same as Any("", data), autodetects MIME type
+func Auto(data interface{}) Data {
+	return Any("", data)
+}
+
 func MakeData(mimeType string, data interface{}) Data {
 	d := Data{
-		Data: BundledMIMEData{
+		Data: MIMEMap{
 			mimeType: data,
 		},
 	}
@@ -94,90 +103,59 @@ func MakeData(mimeType string, data interface{}) Data {
 
 func MakeData3(mimeType string, plaintext string, data interface{}) Data {
 	return Data{
-		Data: BundledMIMEData{
+		Data: MIMEMap{
 			"text/plain": plaintext,
 			mimeType:     data,
 		},
 	}
 }
 
-func Bytes(mimeType string, bytes []byte) Data {
-	if len(mimeType) == 0 {
-		mimeType = http.DetectContentType(bytes)
-	}
-	return MakeData3(mimeType, mimeType, bytes)
-}
-
 func File(mimeType string, path string) Data {
 	bytes, err := ioutil.ReadFile(path)
 	if err != nil {
 		panic(err)
 	}
-	return Bytes(mimeType, bytes)
+	return Any(mimeType, bytes)
 }
 
 func HTML(html string) Data {
-	return String(MIMETypeHTML, html)
+	return MakeData(MIMETypeHTML, html)
 }
 
 func JSON(json map[string]interface{}) Data {
 	return MakeData(MIMETypeJSON, json)
 }
 
 func JavaScript(javascript string) Data {
-	return String(MIMETypeJavaScript, javascript)
+	return MakeData(MIMETypeJavaScript, javascript)
 }
 
 func JPEG(jpeg []byte) Data {
-	return Bytes(MIMETypeJPEG, jpeg)
+	return MakeData(MIMETypeJPEG, jpeg)
 }
 
 func Latex(latex string) Data {
 	return MakeData3(MIMETypeLatex, latex, "$"+strings.Trim(latex, "$")+"$")
 }
 
 func Markdown(markdown string) Data {
-	return String(MIMETypeMarkdown, markdown)
+	return MakeData(MIMETypeMarkdown, markdown)
 }
 
 func Math(latex string) Data {
 	return MakeData3(MIMETypeLatex, latex, "$$"+strings.Trim(latex, "$")+"$$")
 }
 
 func PDF(pdf []byte) Data {
-	return Bytes(MIMETypePDF, pdf)
+	return MakeData(MIMETypePDF, pdf)
 }
 
 func PNG(png []byte) Data {
-	return Bytes(MIMETypePNG, png)
-}
-
-func Reader(mimeType string, r io.Reader) Data {
-	b, err := ioutil.ReadAll(r)
-	if err != nil {
-		panic(err)
-	}
-	return Bytes(mimeType, b)
-}
-
-func String(mimeType string, s string) Data {
-	if len(mimeType) == 0 {
-		mimeType = http.DetectContentType([]byte(s))
-	}
-	return MakeData3(mimeType, s, s)
+	return MakeData(MIMETypePNG, png)
 }
 
 func SVG(svg string) Data {
-	return String(MIMETypeSVG, svg)
-}
-
-func WriterTo(mimeType string, to io.WriterTo) Data {
-	var buf bytes.Buffer
-	_, err := to.WriteTo(&buf)
-	if err != nil {
-		panic(err)
-	}
-	return Bytes(mimeType, buf.Bytes())
+	return MakeData(MIMETypeSVG, svg)
 }
 
 // MIME encapsulates the data and metadata into a Data.
@@ -187,15 +165,15 @@ func WriterTo(mimeType string, to io.WriterTo) Data {
 // The exact structure of value is determined by what the frontend expects.
 // Some easier-to-use functions for common formats supported by the Jupyter frontend
 // are provided by the various functions above.
-func MIME(data, metadata map[string]interface{}) Data {
+func MIME(data, metadata MIMEMap) Data {
 	return Data{data, metadata, nil}
 }
 
 // prepare imports.Package for interpreted code
 var display = imports.Package{
 	Binds: map[string]r.Value{
 		"Any":                r.ValueOf(Any),
-		"Bytes":              r.ValueOf(Bytes),
+		"Auto":               r.ValueOf(Auto),
 		"File":               r.ValueOf(File),
 		"HTML":               r.ValueOf(HTML),
 		"Image":              r.ValueOf(Image),
@@ -219,14 +197,11 @@ var display = imports.Package{
 		"MIMETypeSVG":        r.ValueOf(MIMETypeSVG),
 		"PDF":                r.ValueOf(PDF),
 		"PNG":                r.ValueOf(PNG),
-		"Reader":             r.ValueOf(Reader),
-		"String":             r.ValueOf(String),
 		"SVG":                r.ValueOf(SVG),
-		"WriterTo":           r.ValueOf(WriterTo),
 	},
 	Types: map[string]r.Type{
-		"BundledMIMEData": r.TypeOf((*BundledMIMEData)(nil)).Elem(),
-		"Data":            r.TypeOf((*Data)(nil)).Elem(),
+		"Data":    r.TypeOf((*Data)(nil)).Elem(),
+		"MIMEMap": r.TypeOf((*MIMEMap)(nil)).Elem(),
 	},
 }
 

examples/Display.ipynb

@@ -13,7 +13,7 @@ func Image(img image.Image) Data {
 	data, err := image0(img)
 	if err != nil {
 		return Data{
-			Data: BundledMIMEData{
+			Data: MIMEMap{
 				"ename":     "ERROR",
 				"evalue":    err.Error(),
 				"traceback": nil,
@@ -32,10 +32,10 @@ func image0(img image.Image) (Data, error) {
 		return Data{}, err
 	}
 	return Data{
-		Data: BundledMIMEData{
+		Data: MIMEMap{
 			mime: bytes,
 		},
-		Metadata: BundledMIMEData{
+		Metadata: MIMEMap{
 			mime: imageMetadata(img),
 		},
 	}, nil
@@ -52,9 +52,9 @@ func encodePng(img image.Image) (data []byte, mime string, err error) {
 }
 
 // imageMetadata returns image size, represented as BundledMIMEData{"width": width, "height": height}
-func imageMetadata(img image.Image) BundledMIMEData {
+func imageMetadata(img image.Image) MIMEMap {
 	rect := img.Bounds()
-	return BundledMIMEData{
+	return MIMEMap{
 		"width":  rect.Dx(),
 		"height": rect.Dy(),
 	}

image.go

@@ -37,15 +37,15 @@ type msgReceipt struct {
 	Sockets    SocketGroup
 }
 
-// bundledMIMEData holds data that can be presented in multiple formats. The keys are MIME types
+// MIMEMap holds data that can be presented in multiple formats. The keys are MIME types
 // and the values are the data formatted with respect to its MIME type. All bundles should contain
 // at least a "text/plain" representation with a string value.
-type BundledMIMEData map[string]interface{}
+type MIMEMap = map[string]interface{}
 
-type Data struct {
-	Data      BundledMIMEData `json:"data"`
-	Metadata  BundledMIMEData `json:"metadata"`
-	Transient BundledMIMEData `json:"transient"`
+type Data = struct {
+	Data      MIMEMap
+	Metadata  MIMEMap
+	Transient MIMEMap
 }
 
 // InvalidSignatureError is returned when the signature on a received message does not
@@ -241,22 +241,24 @@ func (receipt *msgReceipt) PublishExecutionInput(execCount int, code string) err
 	)
 }
 
+func ensure(bundle MIMEMap) MIMEMap {
+	if bundle == nil {
+		bundle = make(MIMEMap)
+	}
+	return bundle
+}
+
 // PublishExecuteResult publishes the result of the `execCount` execution as a string.
 func (receipt *msgReceipt) PublishExecutionResult(execCount int, data Data) error {
-	if data.Metadata == nil {
-		data.Metadata = make(BundledMIMEData)
-	}
-	return receipt.Publish("execute_result",
-		struct {
-			ExecCount int             `json:"execution_count"`
-			Data      BundledMIMEData `json:"data"`
-			Metadata  BundledMIMEData `json:"metadata"`
-		}{
-			ExecCount: execCount,
-			Data:      data.Data,
-			Metadata:  data.Metadata,
-		},
-	)
+	return receipt.Publish("execute_result", struct {
+		ExecCount int     `json:"execution_count"`
+		Data      MIMEMap `json:"data"`
+		Metadata  MIMEMap `json:"metadata"`
+	}{
+		ExecCount: execCount,
+		Data:      data.Data,
+		Metadata:  ensure(data.Metadata),
+	})
 }
 
 // PublishExecuteResult publishes a serialized error that was encountered during execution.
@@ -276,13 +278,16 @@ func (receipt *msgReceipt) PublishExecutionError(err string, trace []string) err
 
 // PublishDisplayData publishes a single image.
 func (receipt *msgReceipt) PublishDisplayData(data Data) error {
-	if data.Metadata == nil {
-		data.Metadata = make(BundledMIMEData)
-	}
-	if data.Transient == nil {
-		data.Transient = make(BundledMIMEData)
-	}
-	return receipt.Publish("display_data", data)
+	// copy Data in a struct with appropriate json tags
+	return receipt.Publish("display_data", struct {
+		Data      MIMEMap `json:"data"`
+		Metadata  MIMEMap `json:"metadata"`
+		Transient MIMEMap `json:"transient"`
+	}{
+		Data:      data.Data,
+		Metadata:  ensure(data.Metadata),
+		Transient: ensure(data.Transient),
+	})
 }
 
 const (