class Ball(object):
    pass

b = Ball()
b.__repr__()

print(b)

"""
Explanation: Display of Rich Output
In Python, objects can declare their textual representation using the __repr__ method.
End of explanation
"""


class Ball(object):
    def __repr__(self):
        return 'TEST'

b = Ball()

print(b)

"""
Explanation: Overriding the __repr__ method:
End of explanation
"""


from IPython.display import display

"""
Explanation: IPython expands on this idea and allows objects to declare other, rich representations including:

HTML
JSON
PNG
JPEG
SVG
LaTeX

A single object can declare some or all of these representations; all of them are handled by IPython's display system. .
Basic display imports
The display function is a general purpose tool for displaying different representations of objects. Think of it as print for these rich representations.
End of explanation
"""


from IPython.display import (
    display_pretty, display_html, display_jpeg,
    display_png, display_json, display_latex, display_svg
)

"""
Explanation: A few points:

Calling display on an object will send all possible representations to the Notebook.
These representations are stored in the Notebook document.
In general the Notebook will use the richest available representation.

If you want to display a particular representation, there are specific functions for that:
End of explanation
"""


from IPython.display import Image

i = Image(filename='./ipython-image.png')
display(i)

"""
Explanation: Images
To work with images (JPEG, PNG) use the Image class.
End of explanation
"""


i

"""
Explanation: Returning an Image object from an expression will automatically display it:
End of explanation
"""


Image(url='http://python.org/images/python-logo.gif')

"""
Explanation: An image can also be displayed from raw data or a URL.
End of explanation
"""


from IPython.display import HTML

s = """<table>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
<tr>
<td>row 1, cell 1</td>
<td>row 1, cell 2</td>
</tr>
<tr>
<td>row 2, cell 1</td>
<td>row 2, cell 2</td>
</tr>
</table>"""

h = HTML(s)

display(h)

"""
Explanation: HTML
Python objects can declare HTML representations that will be displayed in the Notebook. If you have some HTML you want to display, simply use the HTML class.
End of explanation
"""


%%html
<table>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
<tr>
<td>row 1, cell 1</td>
<td>row 1, cell 2</td>
</tr>
<tr>
<td>row 2, cell 1</td>
<td>row 2, cell 2</td>
</tr>
</table>

%%html
<style>
#notebook {
    background-color: skyblue;
    font-family: times new roman;
}
</style>

"""
Explanation: You can also use the %%html cell magic to accomplish the same thing.
End of explanation
"""


from IPython.display import Javascript

"""
Explanation: You can remove the abvove styling by using "Cell"$\rightarrow$"Current Output"$\rightarrow$"Clear" with that cell selected.
JavaScript
The Notebook also enables objects to declare a JavaScript representation. At first, this may seem odd as  output is inherently visual and JavaScript is a programming language. However, this opens the door for rich output that leverages the full power of JavaScript and associated libraries such as d3.js for output.
End of explanation
"""


js = Javascript('alert("hi")');

display(js)

"""
Explanation: Pass a string of JavaScript source code to the JavaScript object and then display it.
End of explanation
"""


%%javascript

alert("hi");

"""
Explanation: The same thing can be accomplished using the %%javascript cell magic:
End of explanation
"""


Javascript(
    """$.getScript('https://cdnjs.cloudflare.com/ajax/libs/d3/3.2.2/d3.v3.min.js')"""
)

%%html
<style type="text/css">

circle {
  fill: rgb(31, 119, 180);
  fill-opacity: .25;
  stroke: rgb(31, 119, 180);
  stroke-width: 1px;
}

.leaf circle {
  fill: #ff7f0e;
  fill-opacity: 1;
}

text {
  font: 10px sans-serif;
}

</style>

%%javascript

// element is the jQuery element we will append to
var e = element.get(0);
    
var diameter = 600,
    format = d3.format(",d");

var pack = d3.layout.pack()
    .size([diameter - 4, diameter - 4])
    .value(function(d) { return d.size; });

var svg = d3.select(e).append("svg")
    .attr("width", diameter)
    .attr("height", diameter)
  .append("g")
    .attr("transform", "translate(2,2)");

d3.json("./flare.json", function(error, root) {
  var node = svg.datum(root).selectAll(".node")
      .data(pack.nodes)
    .enter().append("g")
      .attr("class", function(d) { return d.children ? "node" : "leaf node"; })
      .attr("transform", function(d) { return "translate(" + d.x + "," + d.y + ")"; });

  node.append("title")
      .text(function(d) { return d.name + (d.children ? "" : ": " + format(d.size)); });

  node.append("circle")
      .attr("r", function(d) { return d.r; });

  node.filter(function(d) { return !d.children; }).append("text")
      .attr("dy", ".3em")
      .style("text-anchor", "middle")
      .text(function(d) { return d.name.substring(0, d.r / 3); });
});

d3.select(self.frameElement).style("height", diameter + "px");

"""
Explanation: Here is a more complicated example that loads d3.js from a CDN, uses the %%html magic to load CSS styles onto the page and then runs ones of the d3.js examples.
End of explanation
"""


from IPython.display import Audio
Audio("./scrubjay.mp3")

"""
Explanation: Audio
IPython makes it easy to work with sounds interactively. The Audio display class allows you to create an audio control that is embedded in the Notebook. The interface is analogous to the interface of the Image display class. All audio formats supported by the browser can be used. Note that no single format is presently supported in all browsers.
End of explanation
"""


import numpy as np
max_time = 3
f1 = 120.0
f2 = 124.0
rate = 8000.0
L = 3
times = np.linspace(0,L,rate*L)
signal = np.sin(2*np.pi*f1*times) + np.sin(2*np.pi*f2*times)

Audio(data=signal, rate=rate)

"""
Explanation: A NumPy array can be converted to audio. The Audio class normalizes and encodes the data and embeds the resulting audio in the Notebook.
For instance, when two sine waves with almost the same frequency are superimposed a phenomena known as beats occur:
End of explanation
"""


from IPython.display import YouTubeVideo
YouTubeVideo('sjfsUzECqK0')

"""
Explanation: Video
More exotic objects can also be displayed, as long as their representation supports the IPython display protocol.  For example, videos hosted externally on YouTube are easy to load:
End of explanation
"""


from IPython.display import IFrame
IFrame('https://ipython.org', width='100%', height=350)

"""
Explanation: External sites
You can even embed an entire page from another site in an iframe; for example this is IPython's home page:
End of explanation
"""


from IPython.display import FileLink, FileLinks
FileLink('../Visualization/Matplotlib.ipynb')

"""
Explanation: Links to local files
IPython provides builtin display classes for generating links to local files. Create a link to a single file using the FileLink object:
End of explanation
"""


FileLinks('./')

"""
Explanation: Alternatively, to generate links to all of the files in a directory, use the FileLinks object, passing '.' to indicate that we want links generated for the current working directory. Note that if there were other directories under the current directory, FileLinks would work in a recursive manner creating links to files in all sub-directories as well.
End of explanation
"""


