class ExperimentMetricSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
class Meta:
model = ExperimentMetric
exclude = []
extra_kwargs = {'experiment': {'read_only': True}}
class JobStatusSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
class Meta:
model = JobStatus
extra_kwargs = {'job': {'read_only': True}}
exclude = []
class JobSerializer(serializers.ModelSerializer, BuildMixin, ProjectMixin,
UserMixin):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
project = fields.SerializerMethodField()
original = fields.SerializerMethodField()
build_job = fields.SerializerMethodField()
class Meta:
model = Job
fields = (
'id',
'uuid',
'name',
'unique_name',
'pod_id',
'user',
'description',
'created_at',
'updated_at',
'last_status',
'started_at',
'finished_at',
'original',
'cloning_strategy',
'tags',
'project',
'build_job',
'backend',
'is_managed',
)
extra_kwargs = {'is_managed': {'read_only': True}}
def get_original(self, obj):
return obj.original_job.unique_name if obj.original_job else None
class ExperimentGroupSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
project = fields.SerializerMethodField()
user = fields.SerializerMethodField()
class Meta:
model = ExperimentGroup
fields = (
'id',
'uuid',
'name',
'unique_name',
'user',
'description',
'last_status',
'group_type',
'project',
'created_at',
'updated_at',
'started_at',
'finished_at',
'tags',
'concurrency',
'search_algorithm'
)
extra_kwargs = {'group_type': {'read_only': True}}
def get_project(self, obj):
return obj.project.unique_name
def get_user(self, obj):
return obj.user.username
class ProjectNotebookJobSerializer(serializers.ModelSerializer,
BuildMixin,
ProjectMixin,
UserMixin):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
project = fields.SerializerMethodField()
build_job = fields.SerializerMethodField()
class Meta:
model = NotebookJob
fields = (
'id',
'uuid',
'name',
'unique_name',
'pod_id',
'build_job',
'node_scheduled',
'user',
'description',
'created_at',
'updated_at',
'started_at',
'finished_at',
'last_status',
'backend',
'tags',
'project',
)
class DownloadDecisionSerializer(serializers.ModelSerializer):
identifier = fields.UUIDField()
configuration = serializers.SlugRelatedField(slug_field='hash_sum',
queryset=JobFile.objects)
scheduler = serializers.SlugRelatedField(slug_field='type',
queryset=Scheduler.objects)
start_date = TimeStampField()
finish_date = TimeStampField(allow_null=True)
start_sj = TimeStampField(allow_null=True)
finish_sj = TimeStampField(allow_null=True)
start_ts = TimeStampField(allow_null=True)
finish_ts = TimeStampField(allow_null=True)
files = DecisionFilesField(source='files.all')
def validate_identifier(self, value):
if Decision.objects.filter(identifier=value).exists():
return uuid.uuid4()
return value
def create(self, validated_data):
decision_files = validated_data.pop('files')['all']
instance = super(DownloadDecisionSerializer,
self).create(validated_data)
FileSystem.objects.bulk_create(
list(
FileSystem(decision=instance, **fkwargs)
for fkwargs in decision_files))
return instance
class Meta:
model = Decision
exclude = ('job', 'operator')
class JobSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
project = fields.SerializerMethodField()
build_job = fields.SerializerMethodField()
class Meta:
model = Job
fields = (
'id',
'uuid',
'name',
'unique_name',
'user',
'description',
'created_at',
'updated_at',
'last_status',
'started_at',
'finished_at',
'tags',
'project',
'build_job',
)
def get_user(self, obj):
return obj.user.username
def get_project(self, obj):
return obj.project.unique_name
def get_build_job(self, obj):
return obj.build_job.unique_name if obj.build_job else None
class ProjectSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
owner = fields.SerializerMethodField()
class Meta:
model = Project
fields = (
'id',
'uuid',
'user',
'name',
'owner',
'unique_name',
'description',
'tags',
'created_at',
'updated_at',
'is_public',
)
def get_user(self, obj):
return obj.user.username
def get_owner(self, obj):
return obj.owner.name
class BuildJobSerializer(serializers.ModelSerializer, ProjectMixin, UserMixin):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
project = fields.SerializerMethodField()
started_at = fields.DateTimeField(read_only=True)
finished_at = fields.DateTimeField(read_only=True)
class Meta:
model = BuildJob
fields = (
'id',
'uuid',
'name',
'unique_name',
'pod_id',
'user',
'description',
'created_at',
'updated_at',
'started_at',
'finished_at',
'last_status',
'tags',
'project',
'backend',
'is_managed',
)
extra_kwargs = {'is_managed': {'read_only': True}}
class BuildJobSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
project = fields.SerializerMethodField()
project_name = fields.SerializerMethodField()
started_at = fields.DateTimeField(read_only=True)
finished_at = fields.DateTimeField(read_only=True)
class Meta:
model = BuildJob
fields = (
'uuid',
'unique_name',
'user',
'sequence',
'description',
'created_at',
'updated_at',
'last_status',
'started_at',
'finished_at',
'is_running',
'is_done',
'project',
'project_name',
)
def get_user(self, obj):
return obj.user.username
def get_project(self, obj):
return obj.project.uuid.hex
def get_project_name(self, obj):
return obj.project.unique_name
class ExperimentGroupChartViewSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
class Meta:
model = ExperimentGroupChartView
exclude = []
extra_kwargs = {'experiment_group': {'read_only': True}}
class ExperimentGroupSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
project = fields.SerializerMethodField()
project_name = fields.SerializerMethodField()
user = fields.SerializerMethodField()
num_experiments = fields.SerializerMethodField()
num_pending_experiments = fields.SerializerMethodField()
num_running_experiments = fields.SerializerMethodField()
class Meta:
model = ExperimentGroup
fields = (
'uuid', 'unique_name', 'user', 'sequence', 'description',
'project', 'project_name', 'created_at', 'updated_at', 'concurrency',
'num_experiments', 'num_pending_experiments', 'num_running_experiments',)
def get_project(self, obj):
return obj.project.uuid.hex
def get_project_name(self, obj):
return obj.project.unique_name
def get_user(self, obj):
return obj.user.username
def get_num_experiments(self, obj):
return obj.experiments.count()
def get_num_pending_experiments(self, obj):
return obj.pending_experiments.count()
def get_num_running_experiments(self, obj):
return obj.running_experiments.count()
class ProjectTensorboardJobSerializer(serializers.ModelSerializer, BuildMixin):
uuid = fields.UUIDField(format='hex', read_only=True)
user = fields.SerializerMethodField()
project = fields.SerializerMethodField()
build_job = fields.SerializerMethodField()
class Meta:
model = TensorboardJob
fields = (
'id',
'uuid',
'name',
'unique_name',
'pod_id',
'build_job',
'node_scheduled',
'user',
'description',
'created_at',
'updated_at',
'started_at',
'finished_at',
'last_status',
'tags',
'project',
'experiment_group',
'experiment',
)
def get_user(self, obj):
return obj.user.username
def get_project(self, obj):
return obj.project.unique_name
class ExperimentJobSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
experiment = fields.SerializerMethodField()
experiment_name = fields.SerializerMethodField()
resources = JobResourcesSerializer(required=False)
started_at = fields.DateTimeField(read_only=True)
finished_at = fields.DateTimeField(read_only=True)
class Meta:
model = ExperimentJob
fields = (
'uuid',
'unique_name',
'sequence',
'role',
'experiment',
'experiment_name',
'last_status',
'is_running',
'is_done',
'created_at',
'updated_at',
'started_at',
'finished_at',
'resources',
)
def get_experiment(self, obj):
return obj.experiment.uuid.hex
def get_experiment_name(self, obj):
return obj.experiment.unique_name
class CatalogSerializer(serializers.ModelSerializer, CatalogNamesMixin,
TagsSerializerMixin):
query = None
uuid = fields.UUIDField(format='hex', read_only=True)
class Meta:
fields = (
'id',
'uuid',
'name',
'description',
'readme',
'tags',
'created_at',
'updated_at',
)
def update(self, instance, validated_data):
validated_data = self.validated_tags(validated_data=validated_data,
tags=instance.tags)
validated_data = self.validated_name(validated_data,
owner=instance.owner,
query=self.query)
return super().update(instance=instance, validated_data=validated_data)
def create(self, validated_data):
validated_data = self.validated_name(validated_data,
owner=validated_data['owner'],
query=self.query)
try:
return super().create(validated_data)
except Exception as e:
raise ValidationError(e)
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
class YupanaMetadataSerializer(Serializer):
"""Serializer for yupana metadata."""
report_id = fields.UUIDField(source="report_uuid")
host_inventory_api_version = fields.CharField(default="1.0")
source = fields.CharField(default="qpc")
source_metadata = YupanaSourceSerializer(source="*")
report_slices = fields.DictField(source="slices", child=ReportSliceSerializer())
class PDFFormSerializer(serializers.ModelSerializer):
url = serializers.HyperlinkedIdentityField(view_name='api:pdf-form-detail')
id = fields.UUIDField(format='hex', read_only=True)
class Meta(object):
model = PDFForm
fields = ['url', 'id', 'name', 'pdf', 'created']
read_only_fields = ['pdf', 'created']
class YupanaSourceSerializer(Serializer):
"""Format source_metadata for yupana payload."""
report_platform_id = fields.UUIDField(source="report_uuid")
report_type = fields.CharField(default="insights")
report_version = fields.CharField()
qpc_server_report_id = fields.IntegerField(source="report_id")
qpc_server_version = fields.CharField(default=server_version)
qpc_server_id = fields.CharField(default=get_server_id)
class OperationCreateSerializer(serializers.ModelSerializer, IsManagedMixin):
uuid = fields.UUIDField(format="hex", read_only=True)
class Meta:
model = get_run_model()
fields = (
"uuid",
"name",
"description",
"content",
"is_managed",
"tags",
)
def validate(self, attrs):
attrs = super().validate(attrs)
self.check_if_entity_is_managed(attrs=attrs, entity_name="Run")
return attrs
def create(self, validated_data):
is_managed = validated_data["is_managed"]
content = validated_data.get("content")
if content:
is_managed = True if is_managed is None else is_managed
if is_managed and not content:
raise ValidationError(
"Managed runs require a content with valid specification"
)
user = validated_data.get("user")
if is_managed:
try:
op_spec = OperationSpecification.read(content)
except Exception as e:
raise ValidationError(e)
try:
return compile_operation_run(
project_id=validated_data["project"].id,
user_id=user.id if user else None,
op_spec=op_spec,
name=validated_data.get("name"),
description=validated_data.get("description"),
tags=validated_data.get("tags"),
supported_kinds=validated_data.get("supported_kinds"),
)
except (PolyaxonException, ValueError) as e:
raise ValidationError(e)
else:
return create_run(
project_id=validated_data["project"].id,
user_id=user.id if user else None,
name=validated_data.get("name"),
description=validated_data.get("description"),
tags=validated_data.get("tags"),
)
class BuildJobStatusSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
job = fields.SerializerMethodField()
class Meta:
model = BuildJobStatus
exclude = ('id', )
def get_job(self, obj):
return obj.job.uuid.hex
class GPUSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
cluster_node = fields.SerializerMethodField()
class Meta:
model = NodeGPU
exclude = ('id', )
def get_cluster_node(self, obj):
return obj.cluster_node.uuid.hex
class ExperimentMetricSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
experiment = fields.SerializerMethodField()
class Meta:
model = ExperimentMetric
exclude = ('id', )
def get_experiment(self, obj):
return obj.experiment.uuid.hex
class CompanySerializerV1(dse_serializers.CassandraModelSerializer,
BaseCachedSerializerMixin):
"""
Represents a Business Object API View with support for JSON, list, and map
fields.
"""
user = serializers.HiddenField(default=dse_fields.CurrentUserNameDefault())
created_at = serializers.DateTimeField(
default=serializers.CreateOnlyDefault(datetime.utcnow))
address = AddressSerializerV1()
founders = fields.ListField(required=False, child=fields.UUIDField())
specialties = fields.ListField(required=False, child=fields.CharField())
latest_twitter_followers = fields.ListField(required=False,
child=fields.IntegerField())
websites = fields.DictField(required=False, child=fields.CharField())
crawler_config = dse_fields.CassandraJSONFieldAsText(required=False)
extra_data = dse_fields.CassandraJSONFieldAsText(required=False)
class Meta:
error_status_codes = {HTTP_400_BAD_REQUEST: "Bad Request"}
model = Company
fields = (
"_id",
"user",
"created_at",
"updated_at",
"name",
"short_description",
"foundation_date",
"country_code",
"stock_symbol",
"domain",
"last_round",
"round_notes",
"address",
"latitude",
"longitude",
"contact_email",
"founders",
"specialties",
"latest_twitter_followers",
"websites",
"crawler_config",
"extra_data",
"point",
"linestring",
)
read_only_fields = ("_id", "user", "created_at", "updated_at")
class ClusterSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
class Meta:
model = Cluster
fields = (
'uuid',
'version_api',
'created_at',
'updated_at',
)
class ExperimentDeclarationsSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
class Meta:
model = Experiment
fields = (
'id',
'uuid',
'name',
'unique_name',
'declarations',
)
class ExperimentJobSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format='hex', read_only=True)
resources = JobResourcesSerializer(required=False)
started_at = fields.DateTimeField(read_only=True)
finished_at = fields.DateTimeField(read_only=True)
class Meta:
model = ExperimentJob
extra_kwargs = {'experiment': {'read_only': True}}
fields = ('id', 'uuid', 'unique_name', 'role', 'experiment',
'last_status', 'created_at', 'updated_at', 'started_at',
'finished_at', 'resources', 'node_scheduled', 'pod_id')
class ProjectSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format="hex", read_only=True)
class Meta:
model = get_project_model()
fields = (
"uuid",
"name",
"description",
"tags",
"created_at",
"updated_at",
)
class RunStatusSerializer(serializers.ModelSerializer):
uuid = fields.UUIDField(format="hex", read_only=True)
condition = fields.DictField(
write_only=True, allow_empty=True, allow_null=True, required=False
)
class Meta:
model = get_run_model()
fields = ("uuid", "status", "condition", "status_conditions")
extra_kwargs = {
"status": {"read_only": True},
"status_conditions": {"read_only": True},
}
class ExperimentSerializer(serializers.ModelSerializer, BuildMixin,
ProjectMixin, UserMixin):
uuid = fields.UUIDField(format='hex', read_only=True)
original = fields.SerializerMethodField()
user = fields.SerializerMethodField()
experiment_group = fields.SerializerMethodField()
project = fields.SerializerMethodField()
build_job = 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',
'started_at',
'finished_at',
'last_status',
'original',
'cloning_strategy',
'project',
'experiment_group',
'build_job',
'backend',
'is_managed',
'framework',
'tags',
'last_metric',
'params',
)
extra_kwargs = {
'original_experiment': {
'write_only': True
},
'is_managed': {
'read_only': True
}
}
def get_original(self, obj):
return obj.original_experiment.unique_name if obj.original_experiment else None
def get_experiment_group(self, obj):
return obj.experiment_group.unique_name if obj.experiment_group else None
