class PluginJobBaseSerializer(serializers.ModelSerializer):
user = fields.SerializerMethodField()
class Meta:
fields = (
'id',
'user',
'name',
'config',
'pod_id',
'tags', # Need to implement TagsSerializerMixin
)
def get_user(self, obj):
return obj.user.username
def _validate_spec(self, config):
pass
def validate_config(self, config):
# content is optional
if not config:
return config
self._validate_spec(config)
# Resume normal creation
return config
class ActivitySerializer(serializers.ModelSerializer):
title = fields.CharField(source="name")
start = fields.DateTimeField(read_only=True)
end = fields.DateTimeField(read_only=True)
url = fields.URLField(source="get_absolute_url", read_only=True)
textColor = fields.SerializerMethodField("get_text_color")
class Meta:
model = Activity
fields = (
"title",
"type",
"start",
"end",
"location",
"description",
"url",
"fb_event_id",
"textColor",
)
def get_text_color(self, obj):
if obj.start_date == date.today():
return "#FFFFFF"
return ""
class JobCreateSerializer(serializers.ModelSerializer, InClusterMixin):
user = fields.SerializerMethodField()
class Meta:
model = Job
fields = (
'id',
'user',
'name',
'description',
'readme',
'in_cluster',
'data_refs',
'config',
)
def get_user(self, obj):
return obj.user.username
def validate_config(self, config):
"""We only validate the config if passed.
Also we use the JobSpecification to check if this config was
intended as job.
"""
validate_job_spec_config(config)
return config
class PluginJobBaseSerializer(serializers.ModelSerializer):
user = fields.SerializerMethodField()
class Meta:
fields = (
'user',
'content',
'config',
)
def get_user(self, obj):
return obj.user.username
def _validate_spec(self, values):
# content is optional
if not values:
return values
validate_tensorboard_spec_content(values)
# Resume normal creation
return values
def validate_content(self, content):
return self._validate_spec(content)
def validate_config(self, config):
return self._validate_spec(config)
class JobCreateSerializer(serializers.ModelSerializer):
user = fields.SerializerMethodField()
class Meta:
model = Job
fields = (
'user',
'description',
'config',
)
def get_user(self, obj):
return obj.user.username
def validate_config(self, config):
"""We only validate the config if passed.
Also we use the JobSpecification to check if this config was
intended as job.
"""
spec = validate_job_spec_config(config)
if spec.is_job:
# Resume normal creation
return config
# Raise an error to tell the user to use job creation instead
raise ValidationError(
'Current job creation could not be performed.\n'
'The reason is that the specification sent correspond '
'to a `{}`.\n'.format(spec.kind))
class PermissionsSerializer(serializers.Serializer):
permissions = fields.SerializerMethodField('get_permissions')
def get_permissions(self, obj):
request = self.context['request']
allowed = partial(acl.action_allowed, request)
permissions = {
'admin':
allowed('Admin', '%'),
'developer':
request.amo_user.is_developer,
'localizer':
allowed('Localizers', '%'),
'lookup':
allowed('AccountLookup', '%'),
'curator':
allowed('Collections', 'Curate'),
'reviewer':
acl.action_allowed(request, 'Apps', 'Review'),
'webpay': (allowed('Transaction', 'NotifyFailure')
and allowed('ProductIcon', 'Create')),
'stats':
allowed('Stats', 'View'),
'revenue_stats':
allowed('RevenueStats', 'View'),
}
return permissions
class ExperimentCreateSerializer(serializers.ModelSerializer, InClusterMixin,
NamesMixin):
user = fields.SerializerMethodField()
class Meta:
model = Experiment
fields = (
'id',
'user',
'name',
'description',
'readme',
'original_experiment',
'experiment_group',
'config',
'declarations',
'in_cluster',
'run_env',
'data_refs',
'tags',
)
def get_user(self, obj):
return obj.user.username
def validate_config(self, config):
"""We only validate the config if passed.
Also we use the ExperimentSpecification to check if this config was
intended as an experiment.
"""
# config is optional
if not config:
return config
spec = validate_experiment_spec_config(config)
if spec.is_experiment:
# Resume normal creation
return config
# Raise an error to tell the user to use experiment creation instead
raise ValidationError(
'Current experiment creation could not be performed.\n'
'The reason is that the specification sent correspond '
'to a `{}`.\n'.format(spec.kind))
def create(self, validated_data):
validated_data = self.validated_name(validated_data,
query=Experiment.all)
try:
return super().create(validated_data)
except Exception as e:
raise ValidationError(e)
def validate(self, attrs):
if self.initial_data.get(
'check_specification') and not attrs.get('config'):
raise ValidationError('Experiment expects a `config`.')
return attrs
class BuildJobCreateSerializer(serializers.ModelSerializer, InClusterMixin,
NamesMixin):
user = fields.SerializerMethodField()
class Meta:
model = BuildJob
fields = ('id', 'user', 'name', 'description', 'config', 'in_cluster',
'tags')
def get_user(self, obj: 'BuildJob'):
return obj.user.username
def validate_config(self, config: Dict) -> Dict:
"""We only validate the config if passed.
Also we use the BuildSpecification to check if this config was
intended as job.
"""
validate_build_spec_config(config)
return config
def create(self, validated_data):
validated_data = self.validated_name(validated_data,
query=BuildJob.all)
try:
return super().create(validated_data)
except Exception as e:
raise ValidationError(e)
class ExperimentCreateSerializer(serializers.ModelSerializer):
user = fields.SerializerMethodField()
class Meta:
model = Experiment
fields = ('user', 'description', 'content', 'config',
'original_experiment')
def get_user(self, obj):
return obj.user.username
def validate_content(self, content):
"""We only validate the content if passed.
Also we use the GroupSpecification to check if this content was
intended as Group experiments.
"""
# content is optional
if not content:
return content
spec = validate_spec_content(content)
if spec.matrix_space == 1:
# Resume normal creation
return content
# Raise an error to tell the use to use experiment creation instead
raise ValidationError(
'Current experiment creation could not be performed.\n'
'The reason is that the specification sent correspond '
'to a group experiment.\n'
'Please use `create group experiment endpoint`.')
class AddressSerializers(serializers.ModelSerializer):
stu_class = fields.SerializerMethodField()
def get_stu_class(self, obj):
return obj.stu_class.cls_name
class Meta:
model = Student
fields = ('id', 'stu_id', 'stu_class', 'stu_name', 'stu_tel',
'stu_birth')
extra_kwargs = {
'id': {
'help_text': 'id'
},
'stu_id': {
'help_text': '学号'
},
'stu_name': {
'help_text': '姓名'
},
'stu_tel': {
'help_text': '联系方式'
},
'stu_birth': {
'help_text': '出生日期'
},
'stu_class': {
'help_text': '班级'
},
}
class ManagerListSerializer(serializers.Serializer): # pylint: disable=abstract-method
""" Serializer for User manager """
email = fields.SerializerMethodField(validators=(EmailValidator, ))
id = fields.SerializerMethodField()
class Meta(object):
fields = ('email', 'id')
def get_email(self, obj):
if obj["manager_user"] is not None:
return obj["manager_user__email"]
else:
return obj["unregistered_manager_email"]
def get_id(self, obj):
return obj["manager_user"]
class BaseSnippetSerializer(serializers.ModelSerializer):
id = fields.ReadOnlyField(source="pk")
title = fields.SerializerMethodField()
edit_url = fields.SerializerMethodField()
def get_title(self, instance):
return str(instance)
def get_edit_url(self, instance):
return reverse(
"wagtailsnippets:edit",
args=[
instance._meta.app_label,
instance._meta.model_name,
quote(instance.id),
],
)
class NewsItemSerializer(ModelSerializer):
site = fields.SerializerMethodField()
site_url = fields.SerializerMethodField()
excerpt = fields.SerializerMethodField()
class Meta:
model = models.NewsItem
fields = ('title', 'excerpt', 'content', 'tags', 'media_url', 'url',
'site', 'site_url', 'created')
def get_site(self, obj):
return obj.site.name
def get_site_url(self, obj):
return obj.site.link
def get_excerpt(self, obj):
return re.sub("<.*?>", "", obj.excerpt).strip()
class ExperimentSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
experiment_group = fields.SerializerMethodField()
experiment_group_name = fields.SerializerMethodField()
project = fields.SerializerMethodField()
project_name = fields.SerializerMethodField()
num_jobs = fields.SerializerMethodField()
last_metric = fields.SerializerMethodField()
started_at = fields.DateTimeField(read_only=True)
finished_at = fields.DateTimeField(read_only=True)
class Meta:
model = Experiment
fields = (
'id',
'uuid',
'name',
'unique_name',
'user',
'description',
'created_at',
'updated_at',
'last_status',
'last_metric',
'started_at',
'finished_at',
'is_running',
'is_done',
'is_clone',
'project',
'project_name',
'experiment_group',
'tags',
'has_tensorboard',
'experiment_group_name',
'num_jobs',
)
def get_user(self, obj):
return obj.user.username
def get_experiment_group(self, obj):
return obj.experiment_group.uuid.hex if obj.experiment_group else None
def get_experiment_group_name(self, obj):
return obj.experiment_group.unique_name if obj.experiment_group else None
def get_project(self, obj):
return obj.project.uuid.hex
def get_project_name(self, obj):
return obj.project.unique_name
def get_num_jobs(self, obj):
return obj.jobs.count()
def get_last_metric(self, obj):
return {k: round(v, 7) for k, v in obj.last_metric.items()} if obj.last_metric else None
