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