Esempio n. 1
0
 def test_get_config(self):
     config_obj = ConfigObj({"a": 1, "b": {"c": [1, 2, 3, 4, 5]}})
     conf = config_obj.get_config("b")
     assert conf.c == [1, 2, 3, 4,
                       5], "get_config should return a config obj."
     conf = config_obj.get_config(("b.c"))
     assert conf == [1, 2, 3, 4, 5], "get_config should return a value."
     conf = config_obj.get_config("c")
     print("conf: {}".format(conf))
Esempio n. 2
0
    def Trends(self,
               featureSet_to_trend,
               trend_ranges,
               _dtm=None,
               _config: ConfigObj = None):
        """
        Trends is a method that constructs the TrendsCommon generic FeatureFamily. It returns features, slope and y-intercept
        such that the user can understand the trend line and ideally future values for various features.
        :param featureSet_to_trend: A feature set to be trended
        :param trend_ranges: list of ranges to be trended [['1m','12m'], ['1w', '4w']]. Accepted range periods are
        d = day
        w = week
        m = month
        y = year
        :param _dtm: A specific dtm can be passed in but generally the dtm from self should be used
        :param _config: A specific configObj can be passed in but generally the config is taken from self
        :return:
        """
        if _config is None:
            time_helpers = self.config.get_config("time_helpers")
        else:
            time_helpers = _config.get_config("time_helpers")

        dtm = self.dtm if _dtm is None else _dtm
        trends = TrendsCommon(featureSet_to_trend, trend_ranges, dtm,
                              time_helpers)
        return trends
Esempio n. 3
0
    def _create_from_daterange(
        cls,
        dtm: DateTimeManager,
        time_helpers: ConfigObj,
        period_ranges="date_filters.ranges",
    ):
        """
               :param time_helpers: {
                   snapshot_date: "20190225",
                   snapshot_type: "DAILY",
                   partition_col: "p_yyyymm",
                   date_ranges: {
                       "1m": {"start": <val>, "end": <val>, "3m": {"start": <val>, "end": <val>}
                       }
               }
               :return:
               """
        filters = []
        filter_vals = []
        date_ranges = time_helpers.get_config(period_ranges).as_dict()
        partition_col = time_helpers.get_or_else("partition_col", "")
        filter_names = list(date_ranges.keys())
        filter_cols = [partition_col]

        if time_helpers.get_or_else("snapshot_type", "MONTH") == "DAILY":
            date_col = time_helpers.get_or_else(
                "date_col", "No date col specified in the time_helpers config."
                "Daily snapshots require a date_col to be defined")
            filter_cols = [partition_col, date_col]
            for date_range in date_ranges.keys():
                d_filter = dtm.scoped_time_filter(
                    range_dict=date_ranges[date_range])
                filters.append([d_filter])
                filter_vals.append(date_ranges[date_range])

        else:
            for date_range in date_ranges.keys():
                p_filter = dtm.scoped_partition_filter(
                    range_dict=date_ranges[date_range])
                filters.append([p_filter])
                filter_vals.append(date_ranges[date_range])

        return Multiplier(filter_cols, [filter_vals], [filters],
                          [filter_names])