def __init__(self,
name: str,
value: dict,
namespace: Optional[str] = None,
**kwargs):
if not self.validate_name(str(name)) \
or (namespace is not None
and not self.validate_name(str(namespace))):
raise ValueError('dictionary name can contain only letters, ' +
'numbers, underscore and dash')
val_res, val_item = validate_dict(value, (str, int, float, tuple), (
dict,
list,
tuple,
set,
str,
int,
float,
bool,
))
if not val_res:
raise TypeError(
('dictionary contains illegal item: '
'`{}` of type `{}`').format(val_item, type(val_item)))
self.name = str(name)
self.value = format_inf(value) if contains_inf(value) else value
self.namespace = str(namespace)
super(Map, self).__init__(self.cat)
def __init__(self,
name: str,
value: dict,
namespace: Optional[str] = None,
aim_session_id: Optional[int] = None):
if not self.validate_name(str(name)):
ValueError('dictionary name can contain only letters, numbers, ' +
'underscore, dash and space`')
val_res, val_item = validate_dict(value, (str, int, tuple), (
dict,
list,
tuple,
set,
str,
int,
float,
bool,
))
if not val_res:
raise TypeError(
('dictionary contains illegal item: '
'`{}` of type `{}`').format(val_item, type(val_item)))
self.name = re.sub(' +', ' ', str(name))
self.value = value
self.namespace = str(namespace)
super(Map, self).__init__(self.cat)
def __init__(self,
name: str,
value: Union[int, float],
epoch: int = None,
step: int = None,
aim_session_id: Optional[int] = None,
**kwargs):
if not self.validate_name(str(name)):
raise ValueError(
'metric name can contain only letters, numbers, ' +
'underscore, dash and space')
if not isinstance(value, (int, float)):
raise TypeError('metric value must be a type of int or float')
val_res, val_item = validate_dict(kwargs, (
str,
int,
float,
), (
str,
int,
float,
bool,
))
if not val_res:
raise TypeError(
('Metric context contains illegal item: '
'`{}` of type `{}`').format(val_item, type(val_item)))
self.name = re.sub(' +', ' ', str(name))
self.value = value
self.epoch = epoch
self.context = kwargs if len(kwargs.keys()) else {}
self.hashable_context = tuple(sorted(kwargs.items()))
super(Metric, self).__init__(self.cat)
if self.context is not None:
step_meta = self.hashable_context
else:
step_meta = None
self.initialize_step_counter(step,
self.name,
step_meta,
session_id=aim_session_id)
def __init__(self, name: str,
value: Union[int, float],
epoch: int = None,
step: int = None,
__aim_session_id: Optional[int] = None,
**kwargs):
if not self.validate_name(str(name)):
raise ValueError('metric name can contain only letters, numbers, ' +
'underscore and dash')
if not isinstance(value, (int, float)):
raise TypeError('metric value must be a type of int or float')
__aim_session_id = kwargs.get('__aim_session_id')
# Construct context kwargs
context_kwargs = {}
for k, v in kwargs.items():
if not k.startswith('__'):
context_kwargs[k] = v
# Validate context
val_res, val_item = validate_dict(
context_kwargs, (str, int, float,),
(str, int, float, bool,))
if not val_res:
raise TypeError(('Metric context contains illegal item: '
'`{}` of type `{}`').format(val_item,
type(val_item)))
self.name = str(name)
self.value = value
self.epoch = epoch
self.context = context_kwargs if len(context_kwargs.keys()) else {}
self.hashable_context = tuple(sorted(context_kwargs.items()))
super(Metric, self).__init__(self.cat)
if self.context is not None:
step_meta = self.hashable_context
else:
step_meta = None
self.initialize_step_counter(step, self.name, step_meta,
session_id=__aim_session_id)