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))
