class _ArtefactSchema(Schema):
"""
Artefact's marshaller.
"""
valids_artefacts = set()
# Shared
type = fields.Str(required=True)
abstract = fields.Bool(required=False)
# file
path = fields.Str()
# Sql
query = fields.Str()
connector = fields.Str()
# Options
save_options = fields.List(fields.Mapping(keys=fields.Str, required=False))
load_options = fields.List(fields.Mapping(keys=fields.Str, required=False))
@validates_schema
def validate_file(self, data, **kwargs):
errors = {}
if data["type"] in ["csv", "xslx"]:
if "path" not in data:
errors["path"] = ["missing path for csvdataset"]
if errors:
raise ValidationError(errors)
@validates_schema
def validate_query(self, data, **kwargs):
errors = {}
if data["type"] == "odbc":
if "connector" not in data:
errors["odbc"] = ["missing connector for type odbc"]
if "query" not in data:
errors["odbc"] = ["missing query for type odbc"]
if errors:
raise ValidationError(errors)
@validates_schema
def validate_datapane(self, data, **kwargs):
errors = {}
if data["type"] == "datapane":
if "path" not in data:
errors["datapane"] = ["missing path for type datapane"]
if errors:
raise ValidationError(errors)
@post_load
def make_artefact(self, data, **kwargs):
if data["type"] not in _ArtefactSchema.valids_artefacts:
warnings.W020(__name__, inter_type=data["type"])
return Artefact(name=None, **data)
class ConfigSchema(Schema):
heartbeats = fields.List(fields.Nested(HeartbeatSchema),
required=False,
missing=[])
ip = fields.IPv4(required=True)
listeners = fields.List(fields.Nested(ListenerSchema),
required=False,
missing=[])
logging = fields.List(fields.Nested(LoggingSchema),
required=False,
missing=[])
notifiers = fields.List(fields.Nested(NotifierSchema),
required=False,
missing=[])
partitions = fields.Mapping(
keys=fields.String(required=True),
values=fields.String(required=True),
required=True,
)
password = fields.String(missing="")
port = fields.Integer(required=False, missing=4025)
storage = fields.List(fields.Nested(StorageSchema),
required=False,
missing=[])
zones = fields.Mapping(
keys=fields.String(required=True),
values=fields.String(required=True),
required=True,
)
@post_load
def make_config(self, data, **kwargs):
return Config(**data)
class TaskDefinitionSchema(Schema):
""" TaskDefinition serialization schema. """
id = fields.Str(required=True)
name = fields.Str(required=True)
image = fields.Str(required=True)
upstream = fields.Str(allow_none=True)
parent = fields.Str(allow_none=True)
inputs = fields.Dict(missing={})
meta = fields.Dict(missing={})
env = fields.Dict(missing={})
ports = fields.Dict(missing={})
routes = fields.Dict(missing={})
cpu = fields.Str(allow_none=True)
cpu_limit = fields.Str(allow_none=True)
memory = fields.Str(allow_none=True)
memory_limit = fields.Str(allow_none=True)
owner = fields.Str(missing='')
created_at = fields.DateTime('iso',
default=lambda: datetime.now(timezone.utc))
storage = fields.Dict(missing={})
volumes = fields.Mapping(keys=fields.Str(),
values=fields.Mapping(),
missing={})
affinity = fields.Dict(missing={})
@post_load
def make_class(self, data: dict, **kwargs):
return self.make_instance(data)
def make_instance(self, data: dict) -> TaskDefinition:
return TaskDefinition(**data)
class UserSchema(EntitySchema):
class Meta:
unknown = EXCLUDE
user_id = fields.Str(
data_key='userId', dump_only=True,
example="f52706c8-ac08-4f9d-a092-8038d1769825")
user_name = fields.Str(example="Jaime Arango")
user_email = fields.Str(example="*****@*****.**")
user_attributes = fields.Mapping()
user_authorization = fields.Mapping()
class UserSchema(Schema):
class Meta:
unknown = EXCLUDE
id = fields.Str(required=True,
data_key='uid',
example="f52706c8-ac08-4f9d-a092-8038d1769825")
name = fields.Str(example="Jaime Arango")
email = fields.Str(example="*****@*****.**")
attributes = fields.Mapping()
authorization = fields.Mapping()
class MARSHMALLOWClass(Schema):
list_simple = fields.List(fields.Nested(MARSHMALLOWSimpleClass()))
# list_enum = fields.List(fields.Nested(MARSHMALLOWEnumClass()))
tuple_datetime = fields.List(fields.Nested(MARSHMALLOWDateTimeClass()))
dict_complex = fields.Dict(
keys=fields.Int(),
values=fields.Mapping(
keys=fields.Str(),
values=fields.Mapping(keys=fields.UUID(),
values=fields.List(fields.Decimal())),
),
)
class NextflowWeblogSchema(Schema):
class Meta:
unknown = INCLUDE
runName = fields.String()
runId = fields.String()
event = fields.String()
utcTime = fields.DateTime()
metadata = fields.Mapping(
attribute='metadataField'
) # renamed, as `metadata` is reserved in SQLAlchemy
trace = fields.Mapping()
class ParticipantSchema(mm.Schema):
name = fields.String()
email = fields.String()
auth_uid = fields.String()
code = fields.String()
answers = fields.Mapping(fields.DateTime(format=DATETIME_FORMAT),
EnumField(Availability))
class JobSchema(Schema):
id = fields.String()
name = fields.String(validate=validate.Length(min=1))
kwargs = fields.Mapping()
func = fields.Nested(FunctionSchema, required=True)
func_ref = fields.String()
next_run_time = fields.DateTime()
pending = fields.Boolean()
coalesce = fields.Boolean()
max_instances = fields.Integer()
misfire_grace_time = fields.Integer()
trigger = fields.Nested(TriggerSchema, required=True)
@pre_load
def pre_load(self, in_data, **_):
func = in_data['func']
if 'params' in func:
in_data['kwargs'] = func['params']
del func['params']
return in_data
@post_dump
def post_dump(self, output, **_):
func_kwargs = output['kwargs']
for param in output['func']['params']:
param_name = param['name']
if param_name in func_kwargs:
param.update(value=func_kwargs[param_name])
del output['kwargs']
return output
class TriggerSchema(Schema):
type = fields.String(validate=validate.OneOf(['date', 'interval']),
required=True)
params = fields.Mapping()
expression = fields.String(dump_only=True)
@pre_dump
def pre_dump(self, obj, **_):
expression = str(obj)
if isinstance(obj, triggers.DateTrigger):
type = 'date'
params = DateTriggerSchema().dump(obj)
elif isinstance(obj, triggers.IntervalTrigger):
type = 'interval'
params = IntervalTriggerSchema().dump(obj)
else:
raise ValidationError('%r is not a trigger object.' % obj)
return dict(type=type, params=params, expression=expression)
@post_load
def post_load(self, data: dict, **_):
mapping = {
"date": DateTriggerSchema,
"interval": IntervalTriggerSchema
}
return mapping[data['type']]().load(data.get('params', {}))
class _CatalogDataSchema(Schema):
"""
CatalogueData's marshaller.
"""
artefacts = fields.List(fields.Mapping(fields.Str,
fields.Nested(_ArtefactSchema)),
required=True)
connectors = fields.List(fields.Mapping(fields.Str,
fields.Nested(_ConnectorSchema)),
allow_none=True)
@post_load
def make_catalogData(self, data, **kwargs):
return CatalogData(**data)
class RoleValidator(Schema):
Tags = fields.Mapping(keys=fields.String, values=fields.String, allow_none=True)
Name = fields.String(required=False, allow_none=True, validate=aws_resource_name_validator)
Path = fields.String(required=False, allow_none=True, validate=aws_resource_name_validator)
Trusts = ListOrValueField(fields.String, missing=[])
ManagedPolicies = ListOrValueField(fields.String, missing=[])
InAccounts = ListOrValueField(fields.String, missing=[])
Description = fields.String(allow_none=True)
class CodeValidationPayloadSchema(Schema):
valid = fields.Boolean(required=True)
is_demo = fields.Boolean()
account_info = fields.Mapping(keys=fields.Str(), allow_none=True)
@post_load
def make_code_validation_payload(self, data, **kwargs):
return CodeValidationPayload(**data)
class ExternalSiteSchema(Schema):
host = fields.String()
last_seen = fields.DateTime()
feeds = fields.Mapping(keys=fields.String(),
values=fields.Nested(ExternalFeedInfoSchema))
class Meta:
# Pass EXCLUDE as Meta option to keep marshmallow 2 behavior
unknown = EXCLUDE
class CampaignStats(Schema):
total_tasks = fields.Int(required=True)
completed_tasks = fields.Int(required=True)
total_files = fields.Int(required=True)
assigned_files = fields.Int(required=True)
tiers_gamma = fields.Mapping(fields.Str, fields.Float)
can_update_gamma = fields.Bool()
can_compute_gamma = fields.Bool(required=True)
gamma_updating = fields.Bool()
class OrganizationSchema(Schema):
bat = fields.String(required=True)
name = fields.String(required=True)
display = fields.String()
note = fields.String()
work_unit_name = fields.String(required=True, default='hour')
work_unit_per_week = fields.Int(required=True, default=40)
work_unit_admin_ratio = fields.Decimal(required=True, default=0.20)
teams = fields.List(fields.Nested(lambda: TeamSchema(only='bat')))
extra = fields.Mapping()
class ProjectSchema(Schema):
"""Marshmallow schema for a Project object."""
editor = fields.Mapping(keys=fields.Str,
values=fields.Str,
required=True,
allow_none=False)
note_extension = fields.Str(required=True, allow_none=False, default="md")
@post_load
def make_project(self, data, **kwargs):
return Project(**data)
class ValidationErrorSchema(BaseSchema):
invalid_fields = fields.Mapping(
keys=fields.String,
values=fields.List(fields.String),
metadata={
'description': '검증에 실패한 필드 이름과 에러 목록',
'example': {
'someField': ['some error']
},
},
)
class PersonSchema(Schema):
bat = fields.String(required=True)
name = fields.String(required=True)
display = fields.String()
email = fields.Email()
manage = fields.Nested(TeamSchema(only='bat'))
team = fields.Nested(TeamSchema(only='bat'))
work_unit_ratio = fields.Int(default=1)
note = fields.String()
extra = fields.Mapping()
technology_skills = fields.List(
fields.Nested(lambda: Technology_SkillSchema))
class ParticipantSchema(mm.Schema):
id = fields.Int()
name = fields.String()
email = fields.String()
auth_uid = fields.String()
code = fields.String()
answers = fields.Mapping(fields.DateTime(format=DATETIME_FORMAT),
EnumField(Availability))
comment = fields.String()
avatar_url = fields.Function(lambda participant: url_for(
'api.user_avatar',
payload=avatar_payload_from_participant(participant)))
class AWSIAMRolesSpecificationValidator(Schema):
Regions = fields.Mapping(keys=fields.String, values=fields.Nested(RegionValidator), default={})
Accounts = fields.Mapping(keys=fields.String, values=fields.Nested(AccountValidator), default={})
Variables = fields.Mapping(keys=fields.String, values=fields.Nested(VariableValidator), default={})
Policies = fields.Mapping(keys=fields.String, values=fields.Nested(PolicyValidator), required=True)
Roles = fields.Mapping(keys=fields.String(validate=aws_resource_name_validator),
values=fields.Nested(RoleValidator), required=True)
ServiceLinkedRoles = fields.Mapping(keys=fields.String,
values=fields.Nested(ServiceLinkedRoleValidator))
class OrganizationSchema(OrderedBaseSchema):
id = fields.UUID(dump_only=True)
name = fields.String()
root_skill = fields.Nested(SkillSchema(only=("id", )), dump_only=True)
level_map = fields.Mapping(
fields.String,
fields.Float,
missing={
"No knowledge": 0.0,
"Beginner": 1.0,
"Intermediate": 2.0,
"Advanced": 3.0,
"Expert": 4.0,
},
)
class EntitySchema(Schema):
id = fields.Str()
type = fields.Str()
names = fields.Mapping(keys=fields.Str(),
values=fields.Nested(LabelSchema))
descriptions = fields.List(fields.Str())
detailedDescriptions = fields.List(fields.Str())
image = fields.Nested(ImageSchema)
links = fields.List(fields.Url())
categories = fields.List(fields.Str())
#categories = fields.Nested(CategoriesSchema)
@post_load
def make_object(self, data):
return Entity(**data)
class StepSchema(Schema):
step = fields.Str(required=True, allow_none=False)
filter = fields.Nested(StepFilterSchema,
required=False,
allow_none=False,
missing=None)
using = fields.Mapping(keys=fields.Str,
values=fields.Raw,
required=False,
allow_none=False,
missing={})
keep = fields.Str(required=False, allow_none=False, missing="**")
@post_load
def make_step(self, data, **kwargs):
return Step(**data)
class DrawGridSchema(Schema):
compounds = fields.Nested(CompoundsSchema, required=True)
common_core = fields.Nested(
CompoundsSchema,
description=
"Optionally, a single common core structure of all compounds used to align them for plotting.",
)
draw_args = fields.Mapping(
keys=fields.String,
values=fields.Field,
missing={},
description=
"Optional additional arguments passed to RDKit molecule drawing function. "
"See https://www.rdkit.org/docs/source/rdkit.Chem.Draw.html?highlight=molstogridimage#rdkit.Chem.Draw.MolsToGridImage",
example='{"molsPerRow": 6}',
)
class EncryptionProviderConfigSchema(Schema):
"""Marshmallow schema for the encryption provider config in Victoria core
config.
Fields:
provider (str): The type of the provider.
config (Mapping[str, str]): Params to pass to the constructor of the
encryption provider implementation.
"""
provider = fields.Str(required=True)
config = fields.Mapping(keys=fields.Str(), values=fields.Raw(), missing={})
@post_load
def make_encryption_provider_config(self, data, **kwargs):
#pylint: disable=unused-argument
return EncryptionProviderConfig(**data)
class ConfigSchema(Schema):
"""Marshmallow schema for the Config object."""
logging_config = fields.Dict(required=True)
storage_providers = fields.Dict(required=False, default={}, missing={})
encryption_provider = fields.Nested(
encryption.EncryptionProviderConfigSchema,
required=False,
allow_none=True)
plugins_config_location = fields.Mapping(keys=fields.Str(),
values=fields.Str(),
default={})
plugins_config = fields.Dict(required=False, default={}, missing={})
@post_load
def make_config_obj(self, data, **kwargs):
#pylint: disable=unused-argument
return Config(**data)
class ReferenceSchema(Schema):
id = fields.String(required=True)
type = NameEnum(ReferenceType, required=True)
pages = fields.String(required=True)
notes = fields.String(required=True)
lines_cited = fields.List(fields.String(),
required=True,
data_key="linesCited")
document = fields.Mapping(load_default=None, load_only=True)
@post_load
def make_reference(self, data, **kwargs) -> Reference:
data["id"] = BibliographyId(data["id"])
data["lines_cited"] = tuple(data["lines_cited"])
data["document"] = data["document"] and create_object_entry(
data["document"])
return Reference(**data)
class CalculateFingerprintsSchema(Schema):
query = fields.Nested(
CompoundsSchema,
description="Query compounds to be fingerprinted",
required=True,
)
fingerprint_type = fields.String(
validate=validate.OneOf(fingerprint_functions.keys()),
missing="topological",
description="The type of fingerprinting algorithm to be used",
)
fingerprint_args = fields.Mapping(
keys=fields.String,
values=fields.Field,
missing={},
description=
"Optional additional arguments passed to RDKit fingerprinting functions. "
"See https://www.rdkit.org/docs/source/rdkit.Chem.rdmolops.html#rdkit.Chem.rdmolops.RDKFingerprint "
"and https://www.rdkit.org/docs/source/rdkit.Chem.rdMolDescriptors.html#rdkit.Chem.rdMolDescriptors.GetMorganFingerprint",
example='{"minPath": 2, "useHs": false}',
)
class SubstructureSchema(Schema):
query = fields.Nested(
CompoundsSchema,
description=
"Query compounds. Their structure will be compared to the target compounds.",
required=True,
)
target = fields.Nested(
CompoundsSchema,
description=
"Target compounds. The substructure of targets will be scanned for matches with the query structures.",
required=True,
)
substructure_args = fields.Mapping(
keys=fields.String,
values=fields.Field,
missing={},
description=
"Optional additional arguments passed to RDKit substructure matching function. "
"See http://www.rdkit.org/docs/source/rdkit.Chem.rdchem.html#rdkit.Chem.rdchem.Mol.GetSubstructMatches",
example='{"useChirality": True, "maxMatches": 3}',
)
