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}', )