class ResponseSerializer(serializers.Serializer):
document = DictField(child=StatisticsSerializer())
def validate_update_list(self, data):
DictField().run_validation(data)
pks = list(data.keys())
self.validate_pk_list(pks)
values = list(data.values())
self.validate_data_list(values)
class UserSelfSerializer(ModelSerializer):
"""User Serializer for information a user can retrieve about themselves and
update about themselves"""
is_superuser = BooleanField(read_only=True)
avatar = CharField(read_only=True)
groups = SerializerMethodField()
uid = CharField(read_only=True)
settings = DictField(source="attributes.settings", default=dict)
@extend_schema_field(
ListSerializer(child=inline_serializer(
"UserSelfGroups",
{
"name": CharField(read_only=True),
"pk": CharField(read_only=True)
},
)))
def get_groups(self, _: User):
"""Return only the group names a user is member of"""
for group in self.instance.ak_groups.all():
yield {
"name": group.name,
"pk": group.pk,
}
def validate_email(self, email: str):
"""Check if the user is allowed to change their email"""
if self.instance.group_attributes().get(
USER_ATTRIBUTE_CHANGE_EMAIL,
CONFIG.y_bool("default_user_change_email", True)):
return email
if email != self.instance.email:
raise ValidationError("Not allowed to change email.")
return email
def validate_name(self, name: str):
"""Check if the user is allowed to change their name"""
if self.instance.group_attributes().get(
USER_ATTRIBUTE_CHANGE_NAME,
CONFIG.y_bool("default_user_change_name", True)):
return name
if name != self.instance.name:
raise ValidationError("Not allowed to change name.")
return name
def validate_username(self, username: str):
"""Check if the user is allowed to change their username"""
if self.instance.group_attributes().get(
USER_ATTRIBUTE_CHANGE_USERNAME,
CONFIG.y_bool("default_user_change_username", True)):
return username
if username != self.instance.username:
raise ValidationError("Not allowed to change username.")
return username
def save(self, **kwargs):
if self.instance:
attributes: dict = self.instance.attributes
attributes.update(self.validated_data.get("attributes", {}))
self.validated_data["attributes"] = attributes
return super().save(**kwargs)
class Meta:
model = User
fields = [
"pk",
"username",
"name",
"is_active",
"is_superuser",
"groups",
"email",
"avatar",
"uid",
"settings",
]
extra_kwargs = {
"is_active": {
"read_only": True
},
"name": {
"allow_blank": True
},
}
class StatisticsSerializer(serializers.Serializer):
std_dev = FloatField()
avg = FloatField()
cor = DictField(child=FloatField())
class LedgerComputePlanSerializer(serializers.Serializer):
traintuples = ComputePlanTraintupleSerializer(many=True, required=False)
testtuples = ComputePlanTesttupleSerializer(many=True, required=False)
composite_traintuples = ComputePlanCompositeTrainTupleSerializer(
many=True, required=False)
aggregatetuples = ComputePlanAggregatetupleSerializer(many=True,
required=False)
tag = serializers.CharField(min_length=0,
max_length=64,
allow_blank=True,
required=False,
allow_null=True)
metadata = DictField(child=CharField(), required=False, allow_null=True)
clean_models = serializers.BooleanField(required=False)
def get_args(self, key, data):
# convert snake case fields to camel case fields to match chaincode expected inputs
traintuples = []
for data_traintuple in data.get('traintuples', []):
traintuple = {
'key': uuid.uuid4(),
'data_manager_key': data_traintuple['data_manager_key'],
'data_sample_keys': data_traintuple['train_data_sample_keys'],
'algo_key': data_traintuple['algo_key'],
'id': data_traintuple['traintuple_id'],
'metadata': data_traintuple.get('metadata'),
}
if 'in_models_ids' in data_traintuple:
traintuple['in_models_ids'] = data_traintuple['in_models_ids']
if 'tag' in data_traintuple:
traintuple['tag'] = data_traintuple['tag']
traintuples.append(traintuple)
testtuples = []
for data_testtuple in data.get('testtuples', []):
testtuple = {
'key': uuid.uuid4(),
'traintuple_id': data_testtuple['traintuple_id'],
'objective_key': data_testtuple['objective_key'],
'metadata': data_testtuple.get('metadata'),
}
if 'tag' in data_testtuple:
testtuple['tag'] = data_testtuple['tag']
if 'data_manager_key' in data_testtuple:
testtuple['data_manager_key'] = data_testtuple[
'data_manager_key']
if 'test_data_sample_keys' in data_testtuple:
testtuple['data_sample_keys'] = data_testtuple[
'test_data_sample_keys']
testtuples.append(testtuple)
composite_traintuples = []
for data_composite_traintuple in data.get('composite_traintuples', []):
composite_traintuple = {
'key':
uuid.uuid4(),
'algo_key':
data_composite_traintuple['algo_key'],
'data_manager_key':
data_composite_traintuple['data_manager_key'],
'data_sample_keys':
data_composite_traintuple['train_data_sample_keys'],
'id':
data_composite_traintuple['composite_traintuple_id'],
'metadata':
data_composite_traintuple.get('metadata'),
}
if 'tag' in data_composite_traintuple:
composite_traintuple['tag'] = data_composite_traintuple['tag']
if 'in_head_model_id' in data_composite_traintuple:
composite_traintuple[
'in_head_model_id'] = data_composite_traintuple[
'in_head_model_id']
if 'in_trunk_model_id' in data_composite_traintuple:
composite_traintuple[
'in_trunk_model_id'] = data_composite_traintuple[
'in_trunk_model_id']
if 'out_trunk_model_permissions' in data_composite_traintuple:
composite_traintuple['out_trunk_model_permissions'] = {
'process': {
'authorized_ids':
data_composite_traintuple[
'out_trunk_model_permissions']['authorized_ids']
}
}
composite_traintuples.append(composite_traintuple)
aggregatetuples = []
for data_aggregatetuple in data.get('aggregatetuples', []):
aggregatetuple = {
'key': uuid.uuid4(),
'algo_key': data_aggregatetuple['algo_key'],
'worker': data_aggregatetuple['worker'],
'id': data_aggregatetuple['aggregatetuple_id'],
'metadata': data_aggregatetuple.get('metadata'),
}
if 'in_models_ids' in data_aggregatetuple:
aggregatetuple['in_models_ids'] = data_aggregatetuple[
'in_models_ids']
if 'tag' in data_aggregatetuple:
aggregatetuple['tag'] = data_aggregatetuple['tag']
aggregatetuples.append(aggregatetuple)
return {
'key': key,
'traintuples': traintuples,
'testtuples': testtuples,
'composite_traintuples': composite_traintuples,
'aggregatetuples': aggregatetuples,
'metadata': data.get('metadata'),
'tag': data.get('tag'),
'clean_models': data.get('clean_models', False),
}
def create(self, channel_name, key, validated_data):
args = self.get_args(key, validated_data)
return ledger.assets.create_computeplan(channel_name, args)
def update(self, channel_name, key, validated_data):
args = self.get_args(key, validated_data)
del args['tag']
return ledger.assets.update_computeplan(channel_name, args)
class AutosubmitChallenge(Challenge):
"""Autosubmit challenge used to send and navigate a POST request"""
url = CharField()
attrs = DictField(child=CharField())
class AutosubmitChallenge(Challenge):
"""Autosubmit challenge used to send and navigate a POST request"""
url = CharField()
attrs = DictField(child=CharField())
component = CharField(default="ak-stage-autosubmit")
class ProjectSerializer(serializers.Serializer):
id = serializers.IntegerField(read_only=True)
version = serializers.IntegerField(read_only=True)
name = serializers.CharField()
properties = DictField(child=ExtensiblePropertySerializer(read_only=True))
type_full_name = serializers.CharField()
class WorkBatchDetailsSerializer(serializers.Serializer):
id = serializers.IntegerField(read_only=True)
name = serializers.CharField(read_only=True)
properties = DictField(child=ExtensiblePropertySerializer(),
allow_null=True)
created_at = serializers.DateTimeField(read_only=True)
updated_at = serializers.DateTimeField(read_only=True)
cls_full_name = serializers.CharField(read_only=True)
# These are still mocked
transitions = serializers.SerializerMethodField(read_only=True)
substances = serializers.SerializerMethodField(read_only=True)
containers = serializers.SerializerMethodField(read_only=True)
tabs = serializers.SerializerMethodField(read_only=True)
def update(self, instance, validated_data):
if validated_data['properties'] is None:
return instance
for p in validated_data['properties']:
setattr(instance, p, validated_data['properties'][p]['value'])
instance.save()
return instance
# TODO: These are mocked for now
def get_transitions(self, obj):
return [{
'source': 1,
'target': 3,
'type': 'spawn'
} # Substance 1 transitions to substance 3
]
def get_containers(self, obj):
return {'source': [9], 'target': [10]}
def get_substances(self, obj):
return [1, 3]
def get_tabs(self, obj):
return [
{
'title': 'Move samples',
'active': True,
'id': 1,
'key': 'transition'
},
{
'title': 'Files',
'active': False,
'id': 2,
'key': 'files'
},
{
'title': 'Details',
'active': False,
'id': 3,
'key': 'details'
},
{
'title': 'Comments',
'active': False,
'id': 4,
'key': 'comments'
},
]
class EventTopPerUserSerializer(PassiveSerializer):
"""Response object of Event's top_per_user"""
application = DictField()
counted_events = IntegerField()
unique_users = IntegerField()
class UILoginButtonSerializer(PassiveSerializer):
"""Serializer for Login buttons of sources"""
name = CharField()
challenge = DictField()
icon_url = CharField(required=False, allow_null=True)