"""

def wrapper(*args, **kwargs):

self = args[0]

ok = func(*args, **kwargs)

if ok:

safe_print(RUNTIME_CHART_CREATE.format(job_name=self.name,

update_every=self._runtime_counters.FREQ))

return ok

"""Represent a collection of charts

def __init__(self, job_name, priority, cleanup, get_update_every, module_name):

"""

self.job_name = job_name

self.priority = priority

self.cleanup = cleanup

self.get_update_every = get_update_every

self.module_name = module_name

self.charts = dict()

def __len__(self):

return len(self.charts)

def __iter__(self):

return iter(self.charts.values())

def __repr__(self):

return 'Charts({0})'.format(self)

def __str__(self):

return str([chart for chart in self.charts])

def __contains__(self, item):

return item in self.charts

def __getitem__(self, item):

return self.charts[item]

def __delitem__(self, key):

del self.charts[key]

def __bool__(self):

return bool(self.charts)

def __nonzero__(self):

return self.__bool__()

def add_chart(self, params):

"""

params = [self.job_name()] + params

new_chart = Chart(params)

new_chart.params['update_every'] = self.get_update_every()

new_chart.params['priority'] = self.priority

new_chart.params['module_name'] = self.module_name

self.priority += 1

self.charts[new_chart.id] = new_chart

return new_chart

def active_charts(self):

"""Represent a chart"""

def __init__(self, params):

"""

if not isinstance(params, list):

raise ItemTypeError("'chart' must be a list type")

if not len(params) >= 8:

raise ItemValueError("invalid value for 'chart', must be {0}".format(CHART_PARAMS))

self.params = dict(zip(CHART_PARAMS, (p or str() for p in params)))

self.name = '{type}.{id}'.format(type=self.params['type'],

id=self.params['id'])

if self.params.get('chart_type') not in CHART_TYPES:

self.params['chart_type'] = 'absolute'

self.dimensions = list()

self.variables = set()

self.flags = ChartFlags()

self.penalty = 0

def __getattr__(self, item):

try:

return self.params[item]

except KeyError:

raise AttributeError("'{instance}' has no attribute '{attr}'".format(instance=repr(self),

attr=item))

def __repr__(self):

return 'Chart({0})'.format(self.id)

def __str__(self):

return self.id

def __iter__(self):

return iter(self.dimensions)

def __contains__(self, item):

return item in [dimension.id for dimension in self.dimensions]

def add_variable(self, variable):

"""

self.variables.add(ChartVariable(variable))

def add_dimension(self, dimension):

"""

dim = Dimension(dimension)

if dim.id in self:

raise DuplicateItemError("'{dimension}' already in '{chart}' dimensions".format(dimension=dim.id,

chart=self.name))

self.refresh()

self.dimensions.append(dim)

return dim

def hide_dimension(self, dimension_id, reverse=False):

if dimension_id in self:

idx = self.dimensions.index(dimension_id)

dimension = self.dimensions[idx]

dimension.params['hidden'] = 'hidden' if not reverse else str()

self.refresh()

def create(self):

"""

chart = CHART_CREATE.format(**self.params)

dimensions = ''.join([dimension.create() for dimension in self.dimensions])

variables = ''.join([var.set(var.value) for var in self.variables if var])

self.flags.push = False

self.flags.created = True

safe_print(chart + dimensions + variables)

def can_be_updated(self, data):

for dim in self.dimensions:

if dim.get_value(data) is not None:

return True

return False

def update(self, data, interval):

updated_dimensions, updated_variables = str(), str()

for dim in self.dimensions:

value = dim.get_value(data)

if value is not None:

updated_dimensions += dim.set(value)

for var in self.variables:

value = var.get_value(data)

if value is not None:

updated_variables += var.set(value)

if updated_dimensions:

since_last = interval if self.flags.updated else 0

if self.flags.push:

self.create()

chart_begin = CHART_BEGIN.format(type=self.type, id=self.id, since_last=since_last)

safe_print(chart_begin, updated_dimensions, updated_variables, 'END\n')

self.flags.updated = True

self.penalty = 0

else:

self.penalty += 1

self.flags.updated = False

return bool(updated_dimensions)

def obsolete(self):

self.flags.obsoleted = True

if self.flags.created:

safe_print(CHART_OBSOLETE.format(**self.params))

def refresh(self):

self.penalty = 0

self.flags.push = True

"""Represent a dimension"""

def __init__(self, params):

"""

if not isinstance(params, list):

raise ItemTypeError("'dimension' must be a list type")

if not params:

raise ItemValueError("invalid value for 'dimension', must be {0}".format(DIMENSION_PARAMS))

self.params = dict(zip(DIMENSION_PARAMS, (p or str() for p in params)))

self.params['name'] = self.params.get('name') or self.params['id']

if self.params.get('algorithm') not in DIMENSION_ALGORITHMS:

self.params['algorithm'] = 'absolute'

if not isinstance(self.params.get('multiplier'), int):

self.params['multiplier'] = 1

if not isinstance(self.params.get('divisor'), int):

self.params['divisor'] = 1

self.params.setdefault('hidden', '')

def __getattr__(self, item):

try:

return self.params[item]

except KeyError:

raise AttributeError("'{instance}' has no attribute '{attr}'".format(instance=repr(self),

attr=item))

def __repr__(self):

return 'Dimension({0})'.format(self.id)

def __str__(self):

return self.id

def __eq__(self, other):

if not isinstance(other, Dimension):

return self.id == other

return self.id == other.id

def create(self):

return DIMENSION_CREATE.format(**self.params)

def set(self, value):

"""

return DIMENSION_SET.format(id=self.id,

value=value)

def get_value(self, data):

try:

return int(data[self.id])

except (KeyError, TypeError):

"""Represent a chart variable"""

def __init__(self, params):

"""

if not isinstance(params, list):

raise ItemTypeError("'variable' must be a list type")

if not params:

raise ItemValueError("invalid value for 'variable' must be: {0}".format(VARIABLE_PARAMS))

self.params = dict(zip(VARIABLE_PARAMS, params))

self.params.setdefault('value', None)

def __getattr__(self, item):

try:

return self.params[item]

except KeyError:

raise AttributeError("'{instance}' has no attribute '{attr}'".format(instance=repr(self),

attr=item))

def __bool__(self):

return self.value is not None

def __nonzero__(self):

return self.__bool__()

def __repr__(self):

return 'ChartVariable({0})'.format(self.id)

def __str__(self):

return self.id

def __eq__(self, other):

if isinstance(other, ChartVariable):

return self.id == other.id

return False

def __hash__(self):

return hash(repr(self))

def set(self, value):

return CHART_VARIABLE_SET.format(id=self.id,

value=value)

def get_value(self, data):

try:

return int(data[self.id])

except (KeyError, TypeError):

def __init__(self):

self.push = True

self.created = False

self.updated = False