1. FusionChart Django Wrapper
Definition:
Python 2.7 provides some interesting concepts like decorators or wrappers. The function
decorators or wrappers change the action of the original function before or after the execution of
the function. In this type of case the original function does not modify itself but the working is
decorated by the wrapper according to its principal. The easiest example is wrapping a function
return by some html/JavaScript tags. If a function returns some name as output, the decorator can
modify it using the <p>, <b>, <i> tags etc.
Example::
Input:
def get_result(intro):
return “Captain America, {0} in civil war” .format (intro)
def pb_ decorate (func):
def func_wrap(intro):
return “ <p><b>{0}</p></b>” .format (func(intro))
return func_wrap
mah_movie= pb_decorate ( get_result)
print mah_movie ( “Chris Evans”)

2. Output:
<p><b> Captain America, Chris Evans in civil war</b></p>
However, calling the decorating function has a clear shortcut. This kind of function can be
identified prepending ‘@’ in it. In the above example the decorator should be @pb_decorate ().
Django wrapper:
This special type of decorator or wrapper provides the advantage of class based views over the
function based views. The wrapper organizes server side HTTP methods like Get, Post etc using
separate methods instead of branching ( if/else / for/ while). The wrapper also provides object
oriented process like ‘mixins’, ‘prefork working module’ etc. The wrapper uses toolkit and
multiple inheritance (‘mixins’) to increase the extensibility and flexibility of the class based
attributes.
CODE:
from django.http import HttpResponse
from django.views.generic import View
class GreetView(View):
greeting = "Nice Day"
def get(self, request):
return HttpResponse ( self.greeting )
In the above code The URL resolver of the Django wrapper expects the arguments from a
function and not a class therefore the view method serves as the opening point of the class. The

3. view method creates an interface for dispatch () method to identify the type of request
(Get/Post/not allowed response) and works according to it.
Purpose of the Wrapper:
The python module (wrapper) creates an interface between python and a third party library. The
advantage of this kind of module is the full use of only python codes even while calling the non-
python third party library. The ‘Django wrapper’ can be used as following:
 Creating charts (Stacked, Bubble, 2D/3D Pie chart) using HTML/ Javascript codes as a
string to the server
 Creating a SQL database using only python code and interfacing the database abstractly
(OO concept of ‘abstraction’) into the server
The ‘FusionChart Django wrapper’ can create charts using the usual HTML/JavaScript codes
but sending those codes as a string to the server.
Explanation of a Sample using the Wrapper:
To create a chart using the wrapper the user should understand the steps in the codes. The chart
can be used in the project installing the ‘fusioncharts.py’ in the project and applying the classes
and methods under the’ FusionCharts ‘namespace. The charts can be rendered in a webpage
using the server request module of the ‘Django’ wrapper. The code of creating a chart is
explained below in details.
Step1: The HTML/JavaScript codes should be used as a string to create the chart. If the user uses
the ‘FusionCharts’ CDN, then he/she should include the path as a source in the script tag.

4. Code:
<script type="text/javascript"src="http://static.fusioncharts.com/code/latest/fusioncharts.js">
</script>
The ‘src’ attribute identifies the library link for the official CDN.
Step2: The code to create the chart includes the type of chart, data as well as type of parameters
used in this case.
Code:
Inclusion of Filename: app_name/views.py
Inclusion of `fusioncharts.py`
from fusioncharts import FusionCharts
def chart(request):
column2d = FusionCharts("column2d", "ex1" , "1200", "600", "chart-1", "json",
"""{
"chart":
{
"caption":" Targets of Supermarkets ",
"subCaption":"Top 3 stores in February by revenue",
"numberPrefix":"$",

5. "theme":"ocean"
},
"data":
[
{
"label":"Bakersfield Central",
"value":"880000"
},
{
"label":"Garden Groove harbour",
"value":"730000"
},
{
"label":"Los Angeles Topanga",
"value":"590000"
},
]

6. }""")
return render(request, 'index.html', {'output' : column2d.render()})
In the code the arguments of the ‘fusionchart’ identifies Chart type, ID, width, height, format and
source respectively. The chart type is 2d column in this case. The ID identifies the chart in the
HTML source. The data source gives the original values for the chart. IN this case three values
are considered.
Step 3: The URL configuration considers the URL pattern of the chart.
Code:
Inclusion of Filename: app_name/urls.py
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.chart, name='demo1'),
]
Step 4: The last step creates a specific decoration for the chart.
Code:
<h3><b><i>FusionChart</i></b></h3>
<div id="2DchartContainer">{{ output|safe }}</div>

7. The Django wrapper decorates the chart sample importing the JavaScript library in the python
interface only using the python code in the above way.