class CommandInputSchema(CommandParameterSchema):
"""CommandArgument schema."""
class Meta:
"""Meta class."""
rdf_type = [renku.CommandInput]
model = CommandInput
unknown = EXCLUDE
consumes = Nested(renku.consumes, [EntitySchema, CollectionSchema])
mapped_to = Nested(renku.mappedTo, MappedIOStreamSchema, missing=None)
class CommandOutputSchema(CommandParameterSchema):
"""CommandArgument schema."""
class Meta:
"""Meta class."""
rdf_type = [renku.CommandOutput]
model = CommandOutput
unknown = EXCLUDE
create_folder = fields.Boolean(renku.createFolder)
produces = Nested(renku.produces, [EntitySchema, CollectionSchema])
mapped_to = Nested(renku.mappedTo, MappedIOStreamSchema, missing=None)
class AssociationSchema(JsonLDSchema):
"""Association schema."""
class Meta:
"""Meta class."""
rdf_type = prov.Association
model = Association
unknown = EXCLUDE
_id = fields.Id(init_name="id")
plan = Nested(prov.hadPlan, RunSchema)
agent = Nested(prov.agent, [SoftwareAgentSchema, PersonSchema])
class RunSchema(CommitMixinSchema):
"""Run schema."""
class Meta:
"""Meta class."""
rdf_type = [renku.Run, prov.Plan, prov.Entity]
model = Run
unknown = EXCLUDE
command = fields.String(renku.command, missing=None)
successcodes = fields.List(renku.successCodes, fields.Integer(), missing=[0])
subprocesses = Nested(renku.hasSubprocess, nested="OrderedSubprocessSchema", missing=None, many=True)
arguments = Nested(renku.hasArguments, CommandArgumentSchema, many=True, missing=None)
inputs = Nested(renku.hasInputs, CommandInputSchema, many=True, missing=None)
outputs = Nested(renku.hasOutputs, CommandOutputSchema, many=True, missing=None)
class DatasetFileSchema(EntitySchema):
"""DatasetFile schema."""
class Meta:
"""Meta class."""
rdf_type = schema.DigitalDocument
model = DatasetFile
unknown = EXCLUDE
added = fields.DateTime(schema.dateCreated,
format="iso",
extra_formats=("%Y-%m-%d", ))
name = fields.String(schema.name, missing=None)
url = fields.String(schema.url, missing=None)
based_on = Nested(schema.isBasedOn,
"DatasetFileSchema",
missing=None,
propagate_client=False)
external = fields.Boolean(renku.external, missing=False)
source = fields.String(renku.source, missing=None)
@pre_dump
def fix_datetimes(self, obj, many=False, **kwargs):
"""Pre dump hook."""
if many:
return [self.fix_datetimes(o, many=False, **kwargs) for o in obj]
obj.added = self._fix_timezone(obj.added)
return obj
class DatasetSchema(EntitySchema, CreatorMixinSchema):
"""Dataset schema."""
class Meta:
"""Meta class."""
rdf_type = schema.Dataset
model = Dataset
unknown = EXCLUDE
_id = fields.Id(init_name="id", missing=None)
_label = fields.String(rdfs.label, init_name="label", missing=None)
date_published = fields.DateTime(
schema.datePublished,
missing=None,
allow_none=True,
format="%Y-%m-%d",
extra_formats=("iso", "%Y-%m-%dT%H:%M:%S"),
)
description = fields.String(schema.description, missing=None)
identifier = fields.String(schema.identifier)
in_language = Nested(schema.inLanguage, LanguageSchema, missing=None)
keywords = fields.List(schema.keywords,
fields.String(),
missing=None,
allow_none=True)
license = fields.Uri(schema.license, missing=None, allow_none=True)
title = fields.String(schema.name)
url = fields.String(schema.url)
version = fields.String(schema.version, missing=None)
date_created = fields.DateTime(schema.dateCreated,
missing=None,
allow_none=True,
format="iso",
extra_formats=("%Y-%m-%d", ))
files = Nested(schema.hasPart, DatasetFileSchema, many=True)
tags = Nested(schema.subjectOf, DatasetTagSchema, many=True)
same_as = Nested(schema.sameAs, UrlSchema, missing=None)
name = fields.String(schema.alternateName)
@pre_dump
def fix_datetimes(self, obj, many=False, **kwargs):
"""Pre dump hook."""
if many:
return [self.fix_datetimes(o, many=False, **kwargs) for o in obj]
obj.date_published = self._fix_timezone(obj.date_published)
obj.date_created = self._fix_timezone(obj.date_created)
return obj
class CreatorMixinSchema(JsonLDSchema):
"""CreatorMixin schema."""
class Meta:
"""Meta class."""
unknown = EXCLUDE
creators = Nested(schema.creator, PersonSchema, many=True)
class OrderedSubprocessSchema(JsonLDSchema):
"""OrderedSubprocess schema."""
class Meta:
"""Meta class."""
rdf_type = [renku.OrderedSubprocess]
model = OrderedSubprocess
unknown = EXCLUDE
_id = fields.Id(init_name="id")
index = fields.Integer(renku.index)
process = Nested(renku.process, RunSchema)
class UsageSchema(JsonLDSchema):
"""Usage schema."""
class Meta:
"""Meta class."""
rdf_type = prov.Usage
model = Usage
unknown = EXCLUDE
_id = fields.Id(init_name="id")
entity = Nested(
prov.entity,
[EntitySchema, CollectionSchema, DatasetSchema, DatasetFileSchema])
role = fields.String(prov.hadRole, missing=None)
class GenerationSchema(JsonLDSchema):
"""Generation schema."""
class Meta:
"""Meta class."""
rdf_type = prov.Generation
model = Generation
unknown = EXCLUDE
_id = fields.Id(init_name="id")
entity = Nested(
prov.qualifiedGeneration,
[EntitySchema, CollectionSchema, DatasetSchema, DatasetFileSchema],
reverse=True)
role = fields.String(prov.hadRole, missing=None)
class ProjectSchema(JsonLDSchema):
"""Project Schema."""
class Meta:
"""Meta class."""
rdf_type = [schema.Project, prov.Location]
model = Project
unknown = EXCLUDE
name = fields.String(schema.name, missing=None)
created = fields.DateTime(schema.dateCreated, missing=None, format="iso", extra_formats=("%Y-%m-%d",))
version = fields.String(schema.schemaVersion, missing=1)
agent_version = fields.String(schema.agent, missing="pre-0.11.0")
creator = Nested(schema.creator, PersonSchema, missing=None)
_id = fields.Id(init_name="id", missing=None)
@pre_dump
def fix_datetimes(self, obj, many=False, **kwargs):
"""Pre dump hook."""
if many:
return [self.fix_datetimes(o, many=False, **kwargs) for o in obj]
obj.created = self._fix_timezone(obj.created)
return obj