Esempio n. 1
0
    def test_time_series_ref(self):
        result = ReactTable(slicer.metrics.votes) \
            .transform(cont_uni_dim_ref_df,
                       slicer,
                       [
                           slicer.dimensions.timestamp,
                           slicer.dimensions.state
                       ], [
                           ElectionOverElection(slicer.dimensions.timestamp)
                       ])

        self.assertIn('data', result)
        result['data'] = result['data'][:2]  # shorten the results to make the test easier to read

        self.assertEqual({
            'columns': [{'Header': 'Timestamp', 'accessor': '$d$timestamp'},
                        {'Header': 'State', 'accessor': '$d$state'},
                        {'Header': 'Votes', 'accessor': '$m$votes'},
                        {'Header': 'Votes (EoE)', 'accessor': '$m$votes_eoe'}],
            'data': [{
                '$d$state': {'display': 'Texas', 'raw': '1'},
                '$d$timestamp': {'raw': '2000-01-01'},
                '$m$votes': {'display': '6,233,385', 'raw': 6233385},
                '$m$votes_eoe': {'display': '5,574,387', 'raw': 5574387}
            }, {
                '$d$state': {'display': 'California', 'raw': '2'},
                '$d$timestamp': {'raw': '2000-01-01'},
                '$m$votes': {'display': '10,428,632', 'raw': 10428632},
                '$m$votes_eoe': {'display': '9,646,062', 'raw': 9646062}
            }]
        }, result)
Esempio n. 2
0
    def test_operations_evaluated_for_each_reference(self,
                                                     mock_fetch_data: Mock,
                                                     *mocks):
        eoe = ElectionOverElection(slicer.dimensions.timestamp)

        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
        mock_operation.metrics = []

        mock_widget = f.Widget(mock_operation)
        mock_widget.transform = Mock()

        mock_df = {}
        mock_fetch_data.return_value = mock_df

        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
        slicer.data \
            .dimension(slicer.dimensions.timestamp) \
            .reference(eoe) \
            .widget(mock_widget) \
            .fetch()

        mock_operation.apply.assert_has_calls([
            call(mock_df, None),
            call(mock_df, eoe),
        ])
Esempio n. 3
0
    def test_apply_to_timeseries_with_uni_dim_and_ref(self):
        cumprod = CumProd(slicer.metrics.wins)
        result = cumprod.apply(
            cont_uni_dim_ref_df,
            ElectionOverElection(slicer.dimensions.timestamp))

        expected = pd.Series([1., 1, 1, 1, 1, 1, 1, 1, 1, 1],
                             name='$m$wins_eoe',
                             index=cont_uni_dim_ref_df.index)
        pandas.testing.assert_series_equal(expected, result)
Esempio n. 4
0
    def test_apply_to_timeseries_with_uni_dim_and_ref(self):
        rolling_mean = RollingMean(slicer.metrics.wins, 3)
        result = rolling_mean.apply(
            cont_uni_dim_ref_df,
            ElectionOverElection(slicer.dimensions.timestamp))

        expected = pd.Series(
            [np.nan, np.nan, np.nan, np.nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
            name='$m$wins_eoe',
            index=cont_uni_dim_ref_df.index)
        pandas.testing.assert_series_equal(expected, result)
Esempio n. 5
0
    def test_apply_to_timeseries_with_uni_dim_and_ref(self):
        cummean = CumMean(slicer.metrics.votes)
        result = cummean.apply(
            cont_uni_dim_ref_df,
            ElectionOverElection(slicer.dimensions.timestamp))

        expected = pd.Series([
            5574387.0, 9646062.0, 5903886.0, 10037347.0, 6389131.0,
            10776668.333333334, 6793838.5, 11404064.75, 7010664.2, 11662100.4
        ],
                             name='$m$votes_eoe',
                             index=cont_uni_dim_ref_df.index)
        pandas.testing.assert_series_equal(expected, result)
Esempio n. 6
0
    def test_ref_item_with_delta_percentage_formats_prefix_suffix(self):
        exp_ref_item = {
            'key': 'wins_with_suffix_and_prefix_eoe_delta_percent',
            'label': 'Wins (EoE Δ%)',
            'prefix': None,
            'suffix': '%',
            'precision': None,
        }

        ref = ElectionOverElection(slicer.dimensions.timestamp, delta=True, delta_percent=True)
        ref_item = ReferenceItem(slicer.metrics.wins_with_suffix_and_prefix, ref)

        self.assert_object_dict(ref_item, exp_ref_item, self.ref_item_attrs)
Esempio n. 7
0
    def test_base_ref_item(self):
        exp_ref_item = {
            'key': 'wins_with_suffix_and_prefix_eoe',
            'label': 'Wins (EoE)',
            'prefix': '$',
            'suffix': '€',
            'precision': None,
        }

        ref = ElectionOverElection(slicer.dimensions.timestamp)
        ref_item = ReferenceItem(slicer.metrics.wins_with_suffix_and_prefix, ref)

        self.assert_object_dict(ref_item, exp_ref_item, self.ref_item_attrs)
Esempio n. 8
0
    def test_time_series_ref(self):
        result = CSV(slicer.metrics.votes) \
            .transform(cont_uni_dim_ref_df,
                       slicer,
                       [
                           slicer.dimensions.timestamp,
                           slicer.dimensions.state
                                        ], [
                           ElectionOverElection(slicer.dimensions.timestamp)
                       ])

        expected = cont_uni_dim_ref_df.copy() \
            .set_index(fd('state_display'), append=True) \
            .reset_index(fd('state'), drop=True)[[fm('votes'), fm('votes_eoe')]]
        expected.index.names = ['Timestamp', 'State']
        expected.columns = ['Votes', 'Votes (EoE)']

        self.assertEqual(expected.to_csv(), result)
Esempio n. 9
0
    def test_pivot_second_dimension_with_multiple_metrics_and_references(self):
        result = ReactTable(slicer.metrics.votes, slicer.metrics.wins, pivot=[slicer.dimensions.state]) \
            .transform(cont_uni_dim_ref_df,
                       slicer, [
                           slicer.dimensions.timestamp, slicer.dimensions.state
                       ], [
                           ElectionOverElection(slicer.dimensions.timestamp)
                       ])

        self.assertIn('data', result)
        result['data'] = result['data'][:2]  # shorten the results to make the test easier to read

        self.assertEqual({
            'columns': [{'Header': 'Timestamp', 'accessor': '$d$timestamp'},
                        {
                            'Header': 'Votes',
                            'columns': [{'Header': 'Texas', 'accessor': '$m$votes.1'},
                                        {'Header': 'California', 'accessor': '$m$votes.2'}]
                        }, {
                            'Header': 'Votes (EoE)',
                            'columns': [{'Header': 'Texas', 'accessor': '$m$votes_eoe.1'},
                                        {
                                            'Header': 'California',
                                            'accessor': '$m$votes_eoe.2'
                                        }]
                        }, {
                            'Header': 'Wins',
                            'columns': [{'Header': 'Texas', 'accessor': '$m$wins.1'},
                                        {'Header': 'California', 'accessor': '$m$wins.2'}]
                        }, {
                            'Header': 'Wins (EoE)',
                            'columns': [{'Header': 'Texas', 'accessor': '$m$wins_eoe.1'},
                                        {
                                            'Header': 'California',
                                            'accessor': '$m$wins_eoe.2'
                                        }]
                        }],
            'data': [{
                '$d$timestamp': {'raw': '2000-01-01'},
                '$m$votes': {
                    '1': {'display': '6,233,385', 'raw': 6233385},
                    '2': {'display': '10,428,632', 'raw': 10428632}
                },
                '$m$votes_eoe': {
                    '1': {'display': '5,574,387', 'raw': 5574387},
                    '2': {'display': '9,646,062', 'raw': 9646062}
                },
                '$m$wins': {
                    '1': {'display': '1', 'raw': 1},
                    '2': {'display': '1', 'raw': 1}
                },
                '$m$wins_eoe': {
                    '1': {'display': '1', 'raw': 1},
                    '2': {'display': '1', 'raw': 1}
                }
            }, {
                '$d$timestamp': {'raw': '2004-01-01'},
                '$m$votes': {
                    '1': {'display': '7,359,621', 'raw': 7359621},
                    '2': {'display': '12,255,311', 'raw': 12255311}
                },
                '$m$votes_eoe': {
                    '1': {'display': '6,233,385', 'raw': 6233385},
                    '2': {'display': '10,428,632', 'raw': 10428632}
                },
                '$m$wins': {
                    '1': {'display': '1', 'raw': 1},
                    '2': {'display': '1', 'raw': 1}
                },
                '$m$wins_eoe': {
                    '1': {'display': '1', 'raw': 1},
                    '2': {'display': '1', 'raw': 1}
                }
            }]
        }, result)