예제 #1
0
    def test_3_wrong_field_name(self):
        from datatable import DataTable

        data = DataTable("data.csv")

        with self.assertRaises(KeyError):
            next(
                data.find_n(3, where={
                    "Year": "2017",
                    "Variable_cod": "H01",
                }))
예제 #2
0
 def iterBucket(self, *fields):
     copy = self.sorted(*fields)
     currentKey = None
     currentBucket = []
     for data in copy:
         key = tuple(data[field] for field in fields)
         if currentKey is not None and key != currentKey:
             yield currentKey, DataTable(currentBucket)
             currentBucket = []
         currentKey = key
         currentBucket.append(data)
     yield currentKey, DataTable(currentBucket)
예제 #3
0
class TestDataTable(unittest.TestCase):
    '''Test DataTable'''

    def setUp(self):
        import db
        from datatable import DataTable

        self.db = db.getInstance()
        self.datatable = DataTable(self.db, 'disciplines')

    def test_columnDefs(self):
        expected = [
            {'type': 'int(10) unsigned', 'name': 'discipline_id'},
            {'type': 'varchar(30)', 'name': 'code'},
            {'type': 'varchar(45)', 'name': 'name'},
            {'type': 'varchar(255)', 'name': 'description'},
            {'type': 'int(10) unsigned', 'name': 'active'},
            {'type': 'timestamp', 'name': 'last_updated'},
        ]
        sort = lambda r: sorted(r, key=lambda x: x['name'])
        results = sort(self.datatable.columnDefs())
        actual = sort(results)
        expected = sort(expected)
        for old, new in zip(expected, actual):
            self.assertDictEqual(old, new)

    def test_table_columns(self):
        expected = ['discipline_id', 'code', 'name', 'description',
                    'active', 'last_updated']
        results = self.datatable.table_columns
        self.assertEqual(expected, results)

    def test_describe(self):
        sort = lambda r: sorted(r, key=lambda x: x['Field'])
        expected = sort([
            {'Extra': '', 'Default': None, 'Field': 'discipline_id',
             'Key': 'PRI', 'Null': 'NO', 'Type': 'int(10) unsigned'},
            {'Extra': '', 'Default': None, 'Field': 'code',
             'Key': 'MUL', 'Null': 'NO', 'Type': 'varchar(30)'},
            {'Extra': '', 'Default': None, 'Field': 'name',
             'Key': '', 'Null': 'NO', 'Type': 'varchar(45)'},
            {'Extra': '', 'Default': None, 'Field': 'description',
             'Key': '', 'Null': 'YES', 'Type': 'varchar(255)'},
            {'Extra': '', 'Default': None, 'Field': 'active',
             'Key': '', 'Null': 'NO', 'Type': 'int(10) unsigned'},
            {'Extra': 'on update CURRENT_TIMESTAMP',
             'Default': 'CURRENT_TIMESTAMP', 'Field': 'last_updated',
             'Key': '', 'Null': 'NO', 'Type': 'timestamp'}
            ])
        results = sort(self.datatable.describe())
        for old, new in zip(expected, results):
            self.assertDictEqual(old, new)
예제 #4
0
    def result():
        if not cur.description:
            return None
        headers = [h[0] for h in cur.description]

        def zipHeaders(row):
            d = {}
            for i, h in enumerate(headers):
                if h not in d or d[h] is None:
                    d[h] = row[i]
                elif row[i] and row[i] != d[h]:
                    print(
                        'WARNING: query returned multiple columns with the same name (%s) with conflicting data.  Taking the data from the first returned column'
                        % h)
            return d

        theData = [zipHeaders(row) for row in cur.fetchall()]
        if scrub is not None:
            for desc in cur.description:
                replace = scrub(desc)
                if replace is not None:
                    for row in theData:
                        row[desc[0]] = replace(row[desc[0]])
        if customScrub:
            for row in theData:
                for header, fromDbValue in customScrub.items():
                    if row[header] is not None:
                        try:
                            row[header] = fromDbValue(row[header])
                        except:
                            pass
        if indexedResults:
            return Hierarchy.fromTable(theData, index,
                                       set(headers).difference(index))
        return DataTable(theData)
예제 #5
0
파일: test_vlib.py 프로젝트: j-fwk/vlib
class TestDataTable(unittest.TestCase):
    '''Test DataTable'''

    def setUp(self):
        import db
        from datatable import DataTable
        
        self.db = db.getInstance()
        self.datatable = DataTable(self.db, 'disciplines')

    def test_columnDefs(self):
        expected = [
            {'type': 'int(10) unsigned', 'name': 'discipline_id'},
            {'type': 'varchar(30)', 'name': 'code'},
            {'type': 'varchar(45)', 'name': 'name'},
            {'type': 'varchar(255)', 'name': 'description'},
            {'type': 'int(10) unsigned', 'name': 'active'},
            {'type': 'timestamp', 'name': 'last_updated'},
        ]
        sort = lambda r: sorted(r, key=lambda x: x['name'])
        results = sort(self.datatable.columnDefs())
        actual = sort(results)
        expected = sort(expected)
        for old, new in zip(expected, actual):
            self.assertDictEqual(old, new)
예제 #6
0
 def bucket(self, *fields):
     '''Returns a dict of bucket -> DataTable of rows matching that bucket'''
     buckets = defaultdict(lambda: [])
     for data in self:
         key = tuple(data[field] for field in fields)
         buckets[key].append(data)
     return AttributeDict(
         (key, DataTable(bucket)) for key, bucket in buckets.items())
예제 #7
0
def fromDataUrl(url):
    u = urlopen(url)
    s = BeautifulSoup(u.read())
    u.close()
    headers = [td.string for td in s.find('thead').find_children('td')]
    data = [[td.string for td in tr.find_children('td')]
            for tr in s.find('tbody').find_children('tr')]
    return DataTable(dict(zip(headers, row)) for row in data)
예제 #8
0
    def test_4_find_correct_value(self):
        import pandas as pd
        from datatable import DataTable

        my_data = DataTable("data.csv")
        my_result = []
        for match in my_data.find_n(3,
                                    where={
                                        "Year": "2017",
                                        "Variable_code": "H01"
                                    }):
            my_result.append(match[8])

        real_data = pd.read_csv("data.csv")
        real_find = real_data[(real_data["Year"] == 2017)
                              & (real_data["Variable_code"] == "H01")]
        real_result = list(real_find.iloc[:3]["Value"])

        self.assertEqual(my_result, real_result)
예제 #9
0
    def delete_item(self):
        target = self.ids.selectid.text
        conn = sqlite3.connect("expenditure.db")
        cur = conn.cursor()
        cur.execute('DELETE from expenses where id = ?', (target, ))
        conn.commit()

        entry = self.ids.catsearch.get_items()
        entrytable = DataTable(table=entry)
        self.ids.catsearch.clear_widgets()
        self.ids.catsearch.add_widget(entrytable)
예제 #10
0
def custom_datatable():
    """
      data_query_pandas 와 동일한 내용을, pandas같은 라이브러리를 사용하지 않고 직접 class 로 구현하려고 합니다.

      Task 2. DataTable 객체는 find_n 이라는 함수를 완성해 같은 결과가 나오도록 구현해 주세요.
              구현이 완성된 DataTable 은 tests 에 명시된 단위테스트를 통과해야 합니다.
              (평가요소 : 가독성 + 메소드 성능 + 메모리 효율 )

    :return:
    """
    from datatable import DataTable

    data_table = DataTable("data.csv")

    res = []
    for match in data_table.find_n(3,
                                   where={
                                       "Year": "2017",
                                       "Variable_code": "H01",
                                   }):
        res.append(match[8])

    return res
예제 #11
0
def parseFixedWidth(f, headers):
    '''
Parses a Fixed Width file using the given headers
headers are a list of the tuples: (name, start, end),
	where name is the hame of the column,
	start is the (1-based) index of the beginning of the column and
	end is the index of the end of the column
'''
    headers = [(header[0], int(header[1]) - 1, int(header[2]))
               for header in headers]

    def parse():
        for line in f:
            d = AttributeDict()
            for header in headers:
                d[header[0]] = line[header[1]:header[2]]
            yield d

    return DataTable(parse())
예제 #12
0
    def search_cat(self):
        target = self.ids.cat.text
        conn = sqlite3.connect("expenditure.db")
        cur = conn.cursor()
        _entries = OrderedDict()
        _entries['idlist'] = {}
        _entries['amountlist'] = {}
        _entries['categorylist'] = {}
        _entries['messagelist'] = {}
        _entries['datelist'] = {}
        idlist = []
        amountlist = []
        categorylist = []
        messagelist = []
        datelist = []
        rows = None
        if target == "All":
            cur.execute('SELECT * FROM expenses')
            rows = cur.fetchall()
        else:
            cur.execute('SELECT * FROM expenses WHERE category=?', (target, ))
            rows = cur.fetchall()

        for id1, amt, cat, price, dt in rows:
            idlist.append(id1)
            amountlist.append(amt)
            categorylist.append(cat)
            messagelist.append(price)
            datelist.append(dt)
        entrynum = len(amountlist)
        idx = 0
        while idx < entrynum:
            _entries['idlist'][idx] = idlist[idx]
            _entries['amountlist'][idx] = amountlist[idx]
            _entries['categorylist'][idx] = categorylist[idx]
            _entries['messagelist'][idx] = messagelist[idx]
            _entries['datelist'][idx] = datelist[idx]

            idx += 1

        entrytable = DataTable(table=_entries)
        self.ids.catsearch.clear_widgets()
        self.ids.catsearch.add_widget(entrytable)
예제 #13
0
class TestDataTable(unittest.TestCase):
    '''Test DataTable'''
    def setUp(self):
        import db
        from datatable import DataTable

        self.db = db.getInstance()
        self.datatable = DataTable(self.db, 'disciplines')

    def test_columnDefs(self):
        expected = [
            {
                'type': 'int(10) unsigned',
                'name': 'discipline_id'
            },
            {
                'type': 'varchar(30)',
                'name': 'code'
            },
            {
                'type': 'varchar(45)',
                'name': 'name'
            },
            {
                'type': 'varchar(255)',
                'name': 'description'
            },
            {
                'type': 'int(10) unsigned',
                'name': 'active'
            },
            {
                'type': 'timestamp',
                'name': 'last_updated'
            },
        ]
        sort = lambda r: sorted(r, key=lambda x: x['name'])
        results = sort(self.datatable.columnDefs())
        actual = sort(results)
        expected = sort(expected)
        for old, new in zip(expected, actual):
            self.assertDictEqual(old, new)
예제 #14
0
    def confirmed_add(self, instance):
        tempday = str(self.ids.expenseday.text)
        tempmonth = str(self.ids.expensemonth.text)
        tempyear = str(self.ids.expenseyear.text)
        date = tempyear + "-" + tempmonth + "-" + tempday
        conn = sqlite3.connect("expenditure.db")
        cur = conn.cursor()
        cur.execute(
            """ INSERT INTO expenses (amount,category,message,date) VALUES (?,?,?,?)""",
            (self.amount.text, self.category.text, self.message.text, date))
        conn.commit()
        conn.close()
        self.amount.text = ""
        self.category.text = ""
        self.message.text = ""

        self.parent.ids.scnd.ids.catsearch.clear_widgets()
        entry = self.parent.ids.scnd.itemlist.get_items(self)
        entrytable = DataTable(table=entry)
        target = self.parent.ids.scnd.ids.catsearch
        target.add_widget(entrytable)
        self.success()
예제 #15
0
    def test_1_init(self):
        from datatable import DataTable

        DataTable("data.csv")

        self.assertTrue(True)
예제 #16
0
 def originalFromRows(self):
     '''return the original rows being diffed from'''
     return DataTable(
         fromRow for result in self
         for fromRow in result.originalFromRows(self.keyFields))
예제 #17
0
def parseCsv(f, headers=None, sep=',', quot='"'):
    return DataTable(
        AttributeDict(line) for line in csv.DictReader(
            f, fieldnames=headers, delimiter=sep, quotechar=quot))
예제 #18
0
    def setUp(self):
        import db
        from datatable import DataTable

        self.db = db.getInstance()
        self.datatable = DataTable(self.db, 'disciplines')
예제 #19
0
    def __call__(self, doc):
        chartstyle = style.Style(name="chartstyle", family="chart")
        chartstyle.addElement(
            style.GraphicProperties(stroke="none", fillcolor="#ffffff"))
        doc.automaticstyles.addElement(chartstyle)

        mychart = chart.Chart(width=self.width,
                              height=self.height,
                              stylename=chartstyle,
                              attributes={'class': self.charttype})
        doc.chart.addElement(mychart)

        # Title
        if self.title:
            titlestyle = style.Style(name="titlestyle", family="chart")
            titlestyle.addElement(
                style.GraphicProperties(stroke="none", fill="none"))
            titlestyle.addElement(
                style.TextProperties(fontfamily="'Nimbus Sans L'",
                                     fontfamilygeneric="swiss",
                                     fontpitch="variable",
                                     fontsize="13pt"))
            doc.automaticstyles.addElement(titlestyle)
            mytitle = chart.Title(x="185pt", y="27pt", stylename=titlestyle)
            mytitle.addElement(text.P(text=self.title))
            mychart.addElement(mytitle)

        # Subtitle
        if self.subtitle:
            subtitlestyle = style.Style(name="subtitlestyle", family="chart")
            subtitlestyle.addElement(
                style.GraphicProperties(stroke="none", fill="none"))
            subtitlestyle.addElement(
                style.TextProperties(fontfamily="'Nimbus Sans L'",
                                     fontfamilygeneric="swiss",
                                     fontpitch="variable",
                                     fontsize="10pt"))
            doc.automaticstyles.addElement(subtitlestyle)
            subtitle = chart.Subtitle(x="50pt",
                                      y="50pt",
                                      stylename=subtitlestyle)
            subtitle.addElement(text.P(text=self.subtitle))
            mychart.addElement(subtitle)

        # Legend
        legendstyle = style.Style(name="legendstyle", family="chart")
        legendstyle.addElement(style.GraphicProperties(fill="none"))
        legendstyle.addElement(
            style.TextProperties(fontfamily="'Nimbus Sans L'",
                                 fontfamilygeneric="swiss",
                                 fontpitch="variable",
                                 fontsize="8pt"))
        doc.automaticstyles.addElement(legendstyle)

        mylegend = chart.Legend(legendposition="end",
                                legendalign="center",
                                stylename=legendstyle)
        mychart.addElement(mylegend)

        # Plot area
        plotstyle = style.Style(name="plotstyle", family="chart")
        if self.subtype == "stacked":
            percentage = "false"
            stacked = "true"
        elif self.subtype == "percentage":
            percentage = "true"
            stacked = "false"
        else:
            percentage = "false"
            stacked = "false"

        plotstyle.addElement(
            style.ChartProperties(seriessource="columns",
                                  percentage=percentage,
                                  stacked=stacked,
                                  threedimensional=self.threedimensional))
        doc.automaticstyles.addElement(plotstyle)

        plotarea = chart.PlotArea(datasourcehaslabels=self.datasourcehaslabels,
                                  stylename=plotstyle)
        mychart.addElement(plotarea)

        # Style for the X,Y axes
        axisstyle = style.Style(name="axisstyle", family="chart")
        axisstyle.addElement(style.ChartProperties(displaylabel="true"))
        axisstyle.addElement(
            style.TextProperties(fontfamily="'Nimbus Sans L'",
                                 fontfamilygeneric="swiss",
                                 fontpitch="variable",
                                 fontsize="8pt"))
        doc.automaticstyles.addElement(axisstyle)

        # Title for the X axis
        xaxis = chart.Axis(dimension="x",
                           name="primary-x",
                           stylename=axisstyle)
        plotarea.addElement(xaxis)
        xt = chart.Title()
        xaxis.addElement(xt)
        xt.addElement(text.P(text=self.x_axis))

        # Title for the Y axis
        yaxis = chart.Axis(dimension="y",
                           name="primary-y",
                           stylename=axisstyle)
        plotarea.addElement(yaxis)
        yt = chart.Title()
        yaxis.addElement(yt)
        yt.addElement(text.P(text=self.y_axis))

        # chart colors
        piestyle = style.Style(name="series", family="chart")
        piestyle.addElement(style.GraphicProperties(fillcolor="#000000"))
        doc.automaticstyles.addElement(piestyle)

        piestyle = style.Style(name="piestyle.critical", family="chart")
        piestyle.addElement(style.ChartProperties(solidtype="cuboid"))
        piestyle.addElement(style.GraphicProperties(fillcolor=riskCritical))
        doc.automaticstyles.addElement(piestyle)

        piestyle = style.Style(name="piestyle.high", family="chart")
        piestyle.addElement(style.ChartProperties(solidtype="cuboid"))
        piestyle.addElement(style.GraphicProperties(fillcolor=riskHigh))
        doc.automaticstyles.addElement(piestyle)

        piestyle = style.Style(name="piestyle.medium", family="chart")
        piestyle.addElement(style.ChartProperties(solidtype="cuboid"))
        piestyle.addElement(style.GraphicProperties(fillcolor=riskMedium))
        doc.automaticstyles.addElement(piestyle)

        piestyle = style.Style(name="piestyle.low", family="chart")
        piestyle.addElement(style.ChartProperties(solidtype="cuboid"))
        piestyle.addElement(style.GraphicProperties(fillcolor=riskLow))
        doc.automaticstyles.addElement(piestyle)

        piestyle = style.Style(name="piestyle.none", family="chart")
        piestyle.addElement(style.ChartProperties(solidtype="cuboid"))
        piestyle.addElement(style.GraphicProperties(fillcolor=riskNone))
        doc.automaticstyles.addElement(piestyle)

        # Set up the data series. OOo doesn't show correctly without them.
        s = chart.Series(valuescellrangeaddress="local-table.$B$2:.$B$6",
                         labelcelladdress="local-table.$B$1",
                         attributes={'class': self.charttype},
                         stylename="series")
        s.addElement(chart.DataPoint(stylename="piestyle.critical"))
        s.addElement(chart.DataPoint(stylename="piestyle.high"))
        s.addElement(chart.DataPoint(stylename="piestyle.medium"))
        s.addElement(chart.DataPoint(stylename="piestyle.low"))
        s.addElement(chart.DataPoint(stylename="piestyle.none"))
        plotarea.addElement(s)

        # The data are placed in a table inside the chart object - but could also be a
        # table in the main document
        datatable = DataTable(self.values)
        datatable.datasourcehaslabels = self.datasourcehaslabels
        mychart.addElement(datatable())
예제 #20
0

def getSummaryStats(data):
    summary_vals = defaultdict(list)
    cnt = len(data["name"])
    for i in range(cnt):
        key = "|".join([data[c][i] for c in category_cols])
        summary_vals[key].append(data["price"][i])
    for key, vals in summary_vals.iteritems():
        a = numpy.array(vals)
        # print key,':',numpy.mean(a),numpy.std(a),len(vals)
    return summary_vals


print "Loading data"
dt = DataTable(FILENAME)
dt.split(0.10, True)
print "Table size:",
dt.printInfo()

print "Transforming"
dt.apply(getSize, "name", "size", False)
dt.apply(getBrand, "name", "brand", False)
dt.shuffle()

dt_train = dt.copy()
dt_train.split(0.75, True)
print "Training Table size:",
dt_train.printInfo()

dt_test = dt.copy()
예제 #21
0
    def __call__(self, doc):
        chartstyle  = style.Style(name="chartstyle", family="chart")
        chartstyle.addElement( style.GraphicProperties(stroke="none", fillcolor="#ffffff"))
        doc.automaticstyles.addElement(chartstyle)

        mychart = chart.Chart( width="576pt", height="504pt", stylename=chartstyle, attributes={'class':self.charttype})
        doc.chart.addElement(mychart)

        # Title
        if self.title:
            titlestyle = style.Style(name="titlestyle", family="chart")
            titlestyle.addElement( style.GraphicProperties(stroke="none", fill="none"))
            titlestyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",
                    fontfamilygeneric="swiss", fontpitch="variable", fontsize="13pt"))
            doc.automaticstyles.addElement(titlestyle)

            mytitle = chart.Title(x="385pt", y="27pt", stylename=titlestyle)
            mytitle.addElement( text.P(text=self.title))
            mychart.addElement(mytitle)

        # Subtitle
        if self.subtitle:
            subtitlestyle = style.Style(name="subtitlestyle", family="chart")
            subtitlestyle.addElement( style.GraphicProperties(stroke="none", fill="none"))
            subtitlestyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",
                    fontfamilygeneric="swiss", fontpitch="variable", fontsize="10pt"))
            doc.automaticstyles.addElement(subtitlestyle)

            subtitle = chart.Subtitle(x="0pt", y="123pt", stylename=subtitlestyle)
            subtitle.addElement( text.P(text= self.subtitle))
            mychart.addElement(subtitle)

        # Legend
        legendstyle = style.Style(name="legendstyle", family="chart")
        legendstyle.addElement( style.GraphicProperties(fill="none"))
        legendstyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",
                fontfamilygeneric="swiss", fontpitch="variable", fontsize="6pt"))
        doc.automaticstyles.addElement(legendstyle)

        mylegend = chart.Legend(legendposition="end", legendalign="center", stylename=legendstyle)
        mychart.addElement(mylegend)

        # Plot area
        plotstyle = style.Style(name="plotstyle", family="chart")
        if self.subtype == "stacked": percentage="false"; stacked="true"
        elif self.subtype == "percentage": percentage="true"; stacked="false"
        else: percentage="false"; stacked="false"
        plotstyle.addElement( style.ChartProperties(seriessource="columns",
                percentage=percentage, stacked=stacked,
                threedimensional=self.threedimensional))
        doc.automaticstyles.addElement(plotstyle)

        plotarea = chart.PlotArea(datasourcehaslabels=self.datasourcehaslabels, stylename=plotstyle)
        mychart.addElement(plotarea)

        # Style for the X,Y axes
        axisstyle = style.Style(name="axisstyle", family="chart")
        axisstyle.addElement( style.ChartProperties(displaylabel="true"))
        doc.automaticstyles.addElement(axisstyle)

        # Title for the X axis
        xaxis = chart.Axis(dimension="x", name="primary-x", stylename=axisstyle)
        plotarea.addElement(xaxis)
        xt = chart.Title()
        xaxis.addElement(xt)
        xt.addElement(text.P(text=self.x_axis))

        # Title for the Y axis
        yaxis = chart.Axis(dimension="y", name="primary-y", stylename=axisstyle)
        plotarea.addElement(yaxis)
        yt = chart.Title()
        yaxis.addElement(yt)
        yt.addElement(text.P(text=self.y_axis))

        # Data area
        datatable = DataTable( self.values )
        datatable.datasourcehaslabels = self.datasourcehaslabels
        mychart.addElement(datatable())
예제 #22
0
def _fromHtmlTable(table):
    headers = [str(th.string) for th in table.tr.findChildren('th')]
    rows = [[str(td.string) for td in tr.findChildren('td')]
            for tr in table.findChildren('tr') if tr.td]
    return DataTable([headers] + rows)
예제 #23
0
        def __init__(self, **kwargs):
            super().__init__(**kwargs)

            entry = self.get_items()
            entrytable = DataTable(table=entry)
            self.add_widget(entrytable)
예제 #24
0
 def toTable(self):
     return DataTable(self)
예제 #25
0
def fromXML(s):
    '''Expects s to be an xml string
	For each child of the root node named "row", adds a datatable row and pulls the attributes into that row
	'''
    return DataTable(row.attrs for row in BeautifulSoup(s).find_child('row'))
예제 #26
0
    def test_2_wrong_source(self):
        from datatable import DataTable

        with self.assertRaises(FileNotFoundError):
            DataTable("wrong_source.csv")
예제 #27
0
    def sorted(self, *fields):
        def key(row):
            return tuple(sortKey(row.get(field, None)) for field in fields)

        return DataTable(sorted(self, key=key))
예제 #28
0
 def originalToRows(self):
     '''return the original rows being diffed to'''
     return DataTable(toRow for result in self
                      for toRow in result.originalToRows(self.keyFields))
예제 #29
0
	def __call__(self, doc):
		chartstyle  = style.Style(name="chartstyle", family="chart")
		chartstyle.addElement( style.GraphicProperties(stroke="none", fillcolor="#ffffff"))
		doc.automaticstyles.addElement(chartstyle)

		mychart = chart.Chart(width=self.width, height=self.height,stylename=chartstyle, attributes={'class':self.charttype})
		doc.chart.addElement(mychart)

		# Title
		if self.title:
			titlestyle = style.Style(name="titlestyle", family="chart")
			titlestyle.addElement( style.GraphicProperties(stroke="none", fill="none"))
			titlestyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",fontfamilygeneric="swiss", fontpitch="variable", fontsize="13pt"))
			doc.automaticstyles.addElement(titlestyle)
			mytitle = chart.Title(x="185pt", y="27pt", stylename=titlestyle)
			mytitle.addElement( text.P(text=self.title))
			mychart.addElement(mytitle)

		# Subtitle
		if self.subtitle:
			subtitlestyle = style.Style(name="subtitlestyle", family="chart")
			subtitlestyle.addElement( style.GraphicProperties(stroke="none", fill="none"))
			subtitlestyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",fontfamilygeneric="swiss", fontpitch="variable", fontsize="10pt"))
			doc.automaticstyles.addElement(subtitlestyle)
			subtitle = chart.Subtitle(x="50pt", y="50pt", stylename=subtitlestyle)
			subtitle.addElement( text.P(text= self.subtitle))	
			mychart.addElement(subtitle)

		# Legend
		legendstyle = style.Style(name="legendstyle", family="chart")
		legendstyle.addElement( style.GraphicProperties(fill="none"))
		legendstyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",fontfamilygeneric="swiss", fontpitch="variable", fontsize="8pt"))
		doc.automaticstyles.addElement(legendstyle)

		mylegend = chart.Legend(legendposition="end", legendalign="center", stylename=legendstyle)
		mychart.addElement(mylegend)

		# Plot area
		plotstyle = style.Style(name="plotstyle", family="chart")
		if self.subtype == "stacked": 
			percentage="false"; stacked="true"
		elif self.subtype == "percentage": 
			percentage="true"; stacked="false"
		else: 
			percentage="false"; stacked="false"
	
		plotstyle.addElement( style.ChartProperties(seriessource="columns",percentage=percentage, stacked=stacked,threedimensional=self.threedimensional))
		doc.automaticstyles.addElement(plotstyle)
 
		plotarea = chart.PlotArea(datasourcehaslabels=self.datasourcehaslabels, stylename=plotstyle)
		mychart.addElement(plotarea)

		# Style for the X,Y axes
		axisstyle = style.Style(name="axisstyle", family="chart")
		axisstyle.addElement( style.ChartProperties(displaylabel="true"))
		axisstyle.addElement( style.TextProperties(fontfamily="'Nimbus Sans L'",
		fontfamilygeneric="swiss", fontpitch="variable", fontsize="8pt"))
		doc.automaticstyles.addElement(axisstyle)

		# Title for the X axis
		xaxis = chart.Axis(dimension="x", name="primary-x", stylename=axisstyle)
		plotarea.addElement(xaxis)
		xt = chart.Title()
		xaxis.addElement(xt)
		xt.addElement(text.P(text=self.x_axis))

		# Title for the Y axis
		yaxis = chart.Axis(dimension="y", name="primary-y", stylename=axisstyle)
		plotarea.addElement(yaxis)
		yt = chart.Title()
		yaxis.addElement(yt)
		yt.addElement(text.P(text=self.y_axis))

		# chart colors
		piestyle = style.Style(name="series", family="chart")
		piestyle.addElement( style.GraphicProperties(fillcolor="#000000"))
		doc.automaticstyles.addElement(piestyle)

		piestyle = style.Style(name="piestyle.critical", family="chart")
		piestyle.addElement( style.ChartProperties(solidtype="cuboid"))
		piestyle.addElement( style.GraphicProperties(fillcolor=riskCritical))
		doc.automaticstyles.addElement(piestyle)

		piestyle = style.Style(name="piestyle.high", family="chart")
		piestyle.addElement( style.ChartProperties(solidtype="cuboid"))
		piestyle.addElement( style.GraphicProperties(fillcolor=riskHigh))
		doc.automaticstyles.addElement(piestyle)

		piestyle = style.Style(name="piestyle.medium", family="chart")
		piestyle.addElement( style.ChartProperties(solidtype="cuboid"))
		piestyle.addElement( style.GraphicProperties(fillcolor=riskMedium))
		doc.automaticstyles.addElement(piestyle)

		piestyle = style.Style(name="piestyle.low", family="chart")
		piestyle.addElement( style.ChartProperties(solidtype="cuboid"))
		piestyle.addElement( style.GraphicProperties(fillcolor=riskLow))
		doc.automaticstyles.addElement(piestyle)

		piestyle = style.Style(name="piestyle.none", family="chart")
		piestyle.addElement( style.ChartProperties(solidtype="cuboid"))
		piestyle.addElement( style.GraphicProperties(fillcolor=riskNone))
		doc.automaticstyles.addElement(piestyle)

		# Set up the data series. OOo doesn't show correctly without them.
		s = chart.Series(valuescellrangeaddress="local-table.$B$2:.$B$6", labelcelladdress="local-table.$B$1",attributes={'class':self.charttype}, stylename="series")
		s.addElement(chart.DataPoint(stylename="piestyle.critical"))
		s.addElement(chart.DataPoint(stylename="piestyle.high"))
		s.addElement(chart.DataPoint(stylename="piestyle.medium"))
		s.addElement(chart.DataPoint(stylename="piestyle.low"))
		s.addElement(chart.DataPoint(stylename="piestyle.none"))
		plotarea.addElement(s)

		# The data are placed in a table inside the chart object - but could also be a
		# table in the main document
		datatable = DataTable(self.values)
		datatable.datasourcehaslabels = self.datasourcehaslabels
		mychart.addElement(datatable())
예제 #30
0
    # DangerouslySetInnerHTML('''
    #     <link rel="stylesheet" type="text/css" href="//cdn.datatables.net/1.10.12/css/jquery.dataTables.min.css">
    # '''),
    html.Link(href='/static/css/jquery.dataTables.min.css', rel='stylesheet'),
    # html.Link(href='/static/css/dash.css', rel='stylesheet'),

    html.H4('Continents'),
    dcc.Dropdown(
        id='continents',
        options=[{'label': i, 'value': i} for i in DF['continent'].unique()],
    ),

    html.H4('DataTable'),
    DataTable(
        id='example',
        columns=DF.columns.tolist(),
        data=DF.values.tolist(),
    ),
])


@app.server.route('/static/<path:path>')
def static_file(path):
    static_folder = os.path.join(os.getcwd(), 'static')
    return send_from_directory(static_folder, path)


@app.callback(
    Output('example', 'data'),
    [Input('continents', 'value')])
def update_table(continent):
예제 #31
0
def fromCursor(cur,
               scrub=None,
               customScrub=None,
               indexedResults=False,
               index=None):
    '''Expects cur to be a pysql 2.0 - style cursor and returns a (list of) DataTable(s) with the results
	optional parameter scrub is a method which is called for each header (row from cursor.description) to return a replace method
		which is then called on each value for that header
		return None to do nothing on that header
	optional parameters indexedResults and index are used to determine if the results should be collected in an indexed Hierarchy and what index to use in that Hierarchy

	example - using adodbapi to connect to MS SQL server, the following will normalize smalldatetime fields to date objects and datetime fields to datetime objects:

	def parseCursor(cursor):
		def scrub(header):
			if header[1] == 135 and header[5] == 0: #135 is the sql datetime type, header[5] is the size of the field
				def toDate(dt):
					if isinstance(dt, datetime.datetime):
						return dt.date()
					return dt
				return toDate
			elif header[1] == 135:
				def toDateTime(dt):
					if isinstance(dt, datetime.date) and not isinstance(dt, datetime.datetime):
						return datetime.datetime(dt.year, dt.month, dt.day)
					return dt
				return toDateTime
			return None
		return fromCursor(cursor, scrub)
	'''
    if not cur.description:
        return DataTable()

    def result():
        if not cur.description:
            return None
        headers = [h[0] for h in cur.description]

        def zipHeaders(row):
            d = {}
            for i, h in enumerate(headers):
                if h not in d or d[h] is None:
                    d[h] = row[i]
                elif row[i] and row[i] != d[h]:
                    print(
                        'WARNING: query returned multiple columns with the same name (%s) with conflicting data.  Taking the data from the first returned column'
                        % h)
            return d

        theData = [zipHeaders(row) for row in cur.fetchall()]
        if scrub is not None:
            for desc in cur.description:
                replace = scrub(desc)
                if replace is not None:
                    for row in theData:
                        row[desc[0]] = replace(row[desc[0]])
        if customScrub:
            for row in theData:
                for header, fromDbValue in customScrub.items():
                    if row[header] is not None:
                        try:
                            row[header] = fromDbValue(row[header])
                        except:
                            pass
        if indexedResults:
            return Hierarchy.fromTable(theData, index,
                                       set(headers).difference(index))
        return DataTable(theData)

    results = [result()]
    while cur.nextset():
        r = result()
        if r:
            results.append(r)
    if len(results) == 1:
        return results[0]
    return results