def _make_from_meta(cls, **kwargs): mdata = kwargs.setdefault('metadata', {}) version = int(mdata['golem_version']) if version > GOLEM_VERSION: error = GolemScriptError( "Unknown golem version %s" % repr(version)) raise error kwargs['_version'] = version if 'golem_span' in mdata: kwargs['span'] = \ times.make_timedelta(mdata.pop('golem_span')) if 'golem_interval' in mdata: kwargs['interval'] = \ times.make_timedelta(mdata.pop('golem_interval')) if 'golem_lag' in mdata: kwargs['lag'] = \ times.make_timedelta(mdata.pop('golem_lag')) if 'golem_epoch' in mdata: kwargs['epoch'] = \ times.make_datetime(mdata.pop('golem_epoch')) if 'golem_realtime' in mdata: kwargs['realtime'] = bool(mdata.pop('golem_realtime')) if 'golem_name' in mdata: kwargs['name'] = mdata.pop('golem_name') if 'golem_suite_name' in mdata: kwargs['suite_name'] = mdata.pop('golem_suite_name') if 'golem_inputs' in mdata: inputs = [] for meta, spec in mdata.pop('golem_inputs'): inputs.append((cls._make_from_meta(**meta), spec)) kwargs['golem_inputs'] = inputs if 'golem_tags' in mdata: kwargs['tags'] = mdata.pop('golem_tags') if 'golem_loops' in mdata: kwargs['loops'] = mdata.pop('golem_loops') if 'golem_flow_maps' in mdata: kwargs['flow_maps'] = mdata.pop('golem_flow_maps') if 'golem_arg_tags' in mdata: kwargs['arg_tags'] = mdata.pop('golem_arg_tags') if 'golem_repository' in mdata: kwargs['repository'] = mdata.pop('golem_repository') if 'golem_output_templates' in mdata: kwargs['output_templates'] = mdata.pop('golem_output_templates') if 'golem_input_templates' in mdata: kwargs['input_templates'] = mdata.pop('golem_input_templates') if 'golem_query_templates' in mdata: kwargs['query_templates'] = mdata.pop('golem_query_templates') if 'output_groups' in mdata: kwargs['output_groups'] = mdata.pop('output_groups') if 'input_groups' in mdata: kwargs['input_groups'] = mdata.pop('input_groups') return cls(**kwargs)
def test_make_timedelta_10(self): self.assertEqual( make_timedelta('P1Y1M1DT1H1M1.001S'), timedelta(days=396, hours=1, minutes=1, seconds=1, milliseconds=1))
def __init__(self, span=None, interval=None, name=None, suite_name=None, epoch=None, lag=None, realtime=False, repository=None, tags=None, arg_tags=None, loops=None, flow_maps=None, golem_inputs=None, output_templates=None, input_templates=None, query_templates=None, input_groups=None, output_groups=None, _version=None, **kwargs): """ Creates a new :class:`Golem` object from the various data that make up a golem script definition. This should never need to be used by anything outside of the :mod:`golem.model` module. See instead :func:`golem.model.parse_golem_metadata` for a way to retrieve golem script information from serialized metadata or existing scripts. """ Script.__init__(self, **kwargs) self._version = _version self.name = name """ The short name of this golem script, if any. """ if self.name is None: try: self.name = os.path.basename(main.__file__) self.name.replace('.py', '') except AttributeError: self.name = "python" self.suite = suite_name """ The short name of this golem script's suite, if any. """ self._epoch = None """ The epoch which all time bins are relative to. Defaults to midnight of the first Monday after the standard unix epoch. """ if epoch: self._epoch = times.make_datetime(epoch) self.interval = \ times.make_timedelta(interval or self.default_interval) """ A :class:`timedelta` representing the process interval of this :class:`Golem` instance. """ self.span = times.make_timedelta(span or self.interval) """ A :class:`timedelta` representing the data window of this :class:`Golem` instance. """ self.repository = repository """ The default path, if any, for the output results data repository for this :class:`Golem` instance. """ self.realtime = realtime or False """ A boolean value indicating whether results for this :class:`Golem` script can be generated in real time or not. If true, forces a *lag* of 0. """ self._lag = None if lag and not self.realtime: self._lag = times.make_timedelta(lag) if not isinstance(tags, dict): tags = dict(tags or ()) self.tags = tags if not isinstance(arg_tags, dict): arg_tags = dict(arg_tags or ()) self.arg_tags = arg_tags self.flow_maps = tuple(flow_maps or ()) for x in self.flow_maps: name, params = x if isinstance(x, tuple) and isinstance(params, dict): continue maps = [] for name, params in self.flow_maps: maps.append((name, dict(params))) self.flow_maps = tuple(flow_maps) break self.loops = tuple(loops or ()) for item in self.loops: name, x = item vals, groups, group_name, sep = x if all(isinstance(y, tuple) for y in (item, x, vals)) and \ not isinstance(vals, basestring) and \ not (groups and not group_name) and \ (groups and isinstance(groups, dict)): continue loops = [] for name, (vals, groups, group_name, sep) in self.loops: if isinstance(vals, basestring): vals = (vals,) if groups: if not group_name: group_name = name + '_group' if not isinstance(groups, dict): groups = dict(groups) loops.append((name, (vals, groups, group_name, sep))) self.loops = tuple(loops) break self.input_templates = tuple(input_templates or ()) for x in self.input_templates: name, t, spec = x if isinstance(x, tuple): continue templates = [] for name, t, spec in self.input_templates: templates.append((name, t, spec)) self.input_templates = tuple(templates) break self.output_templates = tuple(output_templates or ()) for x in self.output_templates: if isinstance(x, tuple): continue templates = [] for name, t, spec in self.output_templates: templates.append((name, t, spec)) self.output_templates = tuple(templates) break self.query_templates = tuple(query_templates or ()) for x in self.query_templates: if isinstance(x, tuple): continue templates = [] for name, t, spec in self.query_templates: templates.append((name, t, spec)) self.query_templates = tuple(templates) break self.input_groups = tuple(input_groups or ()) self.output_groups = tuple(output_groups or ()) self.golem_inputs = tuple(golem_inputs or ()) self._validate_params()
def test_make_timedelta_8(self): self.assertEqual(make_timedelta('PT1S'), timedelta(seconds=1))
def test_make_timedelta_9(self): self.assertEqual(make_timedelta('PT0.001S'), timedelta(milliseconds=1))
def test_make_timedelta_6(self): self.assertEqual(make_timedelta('PT1H'), timedelta(hours=1))
def test_make_timedelta_7(self): self.assertEqual(make_timedelta('PT1M'), timedelta(minutes=1))
def test_make_timedelta_5(self): self.assertEqual(make_timedelta('P1D'), timedelta(days=1))
def test_make_timedelta_4(self): self.assertEqual(make_timedelta('P1M'), timedelta(days=30))
def test_make_timedelta_3(self): self.assertEqual(make_timedelta('P1Y'), timedelta(days=365))
def test_make_timedelta_2(self): self.assertEqual(make_timedelta(timedelta(2427)), timedelta(2427))
def test_make_timedelta_1(self): self.assertEqual(make_timedelta(timedelta(0)), timedelta(0))