class DeleteBookGenresQuerySchema(Schema): """DELETE book genre query schema for book management.""" book_id = fields.UUID(required=True)
class FooSchema(Schema): foo = fields.String(required=True) bar = fields.String(required=False) baz = fields.UUID(required=False)
def test_invalid_uuid_deserialization(self, in_value): field = fields.UUID() with pytest.raises(ValidationError) as excinfo: field.deserialize(in_value) msg = 'Could not deserialize {0!r} to a UUID object.'.format(in_value) assert msg in str(excinfo)
def _field_method_from_dict(name: str, field_dict: dict): """ Takes the dict from a yaml schema and creates a field appropriate for Marshmallow. """ field_types = { 'string': fields.Str(), 'uuid': fields.UUID(), 'uri': fields.Str(validate=MLSchemaValidators.validate_type_URI), 'datetime': MLSchemaFields.DateTime(), 'semver': fields.Str(validate=MLSchemaValidators.validate_type_semver), 'allowed_schema_types': fields.Str(), 'boolean': fields.Boolean(), 'list_strings': fields.List( fields.Str( validate=MLSchemaValidators.validate_type_string_cast)), 'list_of_tensor_shapes': fields.List(fields.Tuple([fields.Str(), fields.List(fields.Int)])), 'tags': fields.List(fields.Tuple([fields.Str(), fields.Str()])), 'path': fields.Str(validate=MLSchemaValidators.validate_type_path), 'dict': fields.Dict(), 'float': fields.Float(), 'email': fields.Email(), 'bucket': fields.Str(validate=MLSchemaValidators.validate_type_bucket), 'int': fields.Int() } try: if 'meta' in field_dict: # The field is a meta field about the schema, so skip adding a method return None field_type = field_dict['type'].lower() field_declaration = field_types[field_type] except KeyError: raise AttributeError( f"MLSchema Library has no field type named '{field_type}''") # Need to put this first so that we can redeclare the field function. Tried # attaching the regex without using the fields.Str(validate=) format, # and it didn't seem to work. if 'regex' in field_dict: try: re.compile(field_dict['regex']) except re.error: raise AssertionError( f"The regex ('{field_dict['regex']}') does not appear to be a valid regex." ) field_declaration = fields.Str(validate=validate.Regexp( field_dict['regex'], error=f"No match for in field: {name}")) if 'allowed' in field_dict: # TODO: This may be a bug in waiting - would prefer not to overwrite, but instead # just to add. Filed a bug with marshmallow to see. # TODO: Bug - cannot currently support with "list" field_declaration = fields.Str( validate=validate.OneOf(field_dict['allowed'])) if 'required' in field_dict and util.strtobool( MLSchemaValidators.validate_bool_and_return_string( field_dict['required'])): field_declaration.required = True if 'empty' in field_dict and util.strtobool( MLSchemaValidators.validate_bool_and_return_string( field_dict['empty'])): field_declaration.allow_none = True return field_declaration
class HostSchema(Schema): class Meta: ordered = True name = NameField( required=True, data_key="hostname" ) # hostname for network use (i.e. fqdn, hostname, or, if necessary, IP) control_name = fields.Str( allow_none=True, missing=None) # i.e., container ID for DOCKER (optional) johann_id = fields.UUID(allow_none=True, missing=None) image = fields.Str(allow_none=True, missing=None) user = fields.Str(allow_none=True, missing=None) pwd_env = fields.Str(allow_none=True, missing=None) os = EnumField(HostOS, allow_none=True, missing=None) python_path = fields.Str(allow_none=True, missing=None) python_ver = LaxStringField(allow_none=True, missing=None) pmtr_variant = EnumField(PmtrVariant, allow_none=True, missing=None) control_method = fields.Str(allow_none=True, missing=None) pip_offline_install = fields.Boolean(allow_none=True, missing=None) tuning = fields.Boolean(dump_only=True) pending_create = fields.Boolean(dump_only=True) celery_task_ids = fields.List( fields.Str(), dump_only=True ) # note that finished tasks may be cleared from this list at any time last_checked_exists = fields.DateTime(dump_only=True) @validates("python_ver") def validate_python_ver(self, value): if value is not None and value not in config.SUPPORTED_PYTHON_VERSIONS: raise MarshmallowValidationError( f"Unsupported python version '{value}'") @validates("control_method") def validate_control_method(self, value): if value is not None and value not in config.HOST_CONTROL_CLASS_NAMES: raise MarshmallowValidationError( f"Unrecognized control method '{value}'") @post_load def make_host(self, data: Dict[str, Any], **kwargs) -> "Host": name = data["name"] control_name = data["control_name"] # validate name and control_name if name != safe_name(name): raise MarshmallowValidationError( f"Name '{name}' does not appear to be a valid hostname") if control_name and control_name != safe_name(control_name): raise MarshmallowValidationError( f"Control name '{control_name}' does not appear to be valid") # validate pmtr variant if data["pmtr_variant"]: try: PmtrVariant(data["pmtr_variant"]) except ValueError: raise MarshmallowValidationError( f"PMTR variant '{data['pmtr_variant']}' is invalid") # validate control method if (data["control_method"] and data["control_method"] not in config.HOST_CONTROL_CLASS_NAMES): raise MarshmallowValidationError( f"Control method '{data['control_method']}' is invalid") return Host(**data)
class APIKeyIdentifierBase(Schema): id = fields.UUID(required=True, allow_none=False)
class RepositorySchema(Schema): id = fields.UUID(dump_only=True) owner_name = fields.Str(dump_only=True) name = fields.Str(dump_only=True) url = fields.Str(dump_only=True) provider = fields.Str(dump_only=True) backend = EnumField(RepositoryBackend, dump_only=True) created_at = fields.DateTime(attribute="date_created", dump_only=True) full_name = fields.Method("get_full_name", dump_only=True) latest_build = fields.Nested("BuildSchema", exclude=("repository", ), dump_only=True) public = fields.Bool() permissions = fields.Nested(PermissionSchema, allow_none=True, dump_only=True) @pre_dump(pass_many=True) def process_permission(self, data, many): user = self.context.get("user") if not user: return data if not many: items = [data] else: items = data access = dict( db.session.query(RepositoryAccess.repository_id, RepositoryAccess.permission).filter( RepositoryAccess.user_id == user.id, RepositoryAccess.repository_id.in_( [i.id for i in items]), )) for item in items: permission = access.get(item.id) or Permission.none item.permissions = { "read": Permission.read in permission, "write": Permission.write in permission, "admin": Permission.admin in permission, } return data @pre_dump(pass_many=True) def process_latest_build(self, data, many): if many: latest_builds = get_latest_builds(data, Result.passed) for repo in data: repo.latest_build = latest_builds.get(repo.id) else: latest_builds = get_latest_builds([data], Result.passed) data.latest_build = latest_builds.get(data.id) return data @post_load def make_instance(self, data): if self.context.get("repository"): obj = self.context["repository"] for key, value in data.items(): if getattr(obj, key) != value: setattr(obj, key, value) else: obj = Repository(**data) return obj def get_full_name(self, obj): return "{}/{}/{}".format(obj.provider, obj.owner_name, obj.name)
class RoomDeleteSchema(Schema): id = fields.UUID(required=True)
class MessagePostSchema(Schema): room_id = fields.UUID(required=True) author = fields.Nested(UserGetSchema, required=True) # TODO: replace with uuid data = fields.Str(required=True)
class UserDeleteSchema(Schema): id = fields.UUID(required=True)
class RoomPostSchema(Schema): owner_id = fields.UUID(required=True) # TODO: just return uuid, not full nested user # owner = relationship('User', back_populates='rooms_owned') # IDK why there is two of them name = fields.Str(required=True) visible = fields.Boolean(required=True) password = fields.Str() # may be empty, no password then
class UserPutSchema(Schema): id = fields.UUID(required=True) # you must supply uuid for the user you wish to modify # TODO ^ obtained from auth, possibly unnecessary username = fields.Str() password = fields.Str(load_only=True) email = fields.Email()
class ClasificationDataSchema(Schema): id = fields.UUID() description = fields.Str() vocabulary = fields.Str() data = fields.Raw(many=False)
class UpdateBookGenreBodySchema(Schema): """PATCH book genre body schema for book management.""" book_id = fields.UUID(required=True) genre_name = fields.String(required=True)
class MemberSchema(Schema): uuid = fields.UUID() name = fields.String() server = fields.Integer()
class MessageDeleteSchema(Schema): room_id = fields.UUID(required=True) id = fields.Integer(required=True)
class ExtendedTrialSchema(TrialSchema): """Extended trial schema """ blank_duration_range = fields.List( fields.Float, required=True, ) blank_screen_timeout = fields.Bool( required=True, ) color = fields.String( required=True, ) computer_name = fields.String( required=True, ) distribution_mean = fields.Float( required=True, ) LDT_mode = fields.String( required=True, ) lick_frames = fields.List( fields.Integer(strict=True), required=True, ) mouse_id = fields.String( required=True, ) number_of_rewards = fields.Integer( required=True, strict=True, ) prechange_minimum = fields.Float( required=True, ) response = fields.Float( required=True, ) response_type = fields.String( required=True, ) response_window = fields.List( fields.Float, required=True, ) reward_licks = fields.List( fields.Float, required=True, allow_none=True, ) reward_lick_count = fields.Integer( required=True, # strict=True, allow_none=True, ) reward_lick_latency = fields.Float( allow_none=True, allow_nan=True, ) reward_rate = fields.Float( allow_none=True, allow_nan=True, ) rig_id = fields.String( required=True, ) session_duration = fields.Float( required=True, ) stage = fields.String( required=True, ) stim_duration = fields.Float( required=True, ) stimulus = fields.String( required=True, ) stimulus_distribution = fields.String( required=True, ) task = fields.String( required=True, ) trial_type = fields.String( required=True, ) user_id = fields.String( required=True, ) startdatetime = FriendlyDateTime( required=True, strict=True, ) date = FriendlyDate( required=True, ) year = fields.Integer( strict=True ) month = fields.Integer( required=True, strict=True, ) day = fields.Integer( required=True, strict=True, ) hour = fields.Integer( required=True, strict=True, ) dayofweek = fields.Integer( strict=True, required=True, ) behavior_session_uuid = fields.UUID( required=True, )
class UserGetSchema(Schema): id = fields.UUID(required=True)
def test_invalid_uuid_deserialization(self, in_value): field = fields.UUID() with pytest.raises(ValidationError) as excinfo: field.deserialize(in_value) assert excinfo.value.args[0] == 'Not a valid UUID.'
from .manager import MediationManager, MediationManagerError from .message_types import SPEC_URI from .messages.inner.keylist_update_rule import ( KeylistUpdateRule, KeylistUpdateRuleSchema, ) from .messages.keylist_query import KeylistQuerySchema from .messages.keylist_update import KeylistUpdateSchema from .messages.mediate_deny import MediationDenySchema from .messages.mediate_grant import MediationGrantSchema from .models.mediation_record import MediationRecord, MediationRecordSchema CONNECTION_ID_SCHEMA = fields.UUID( description="Connection identifier (optional)", required=False, example=UUIDFour.EXAMPLE, ) MEDIATION_ID_SCHEMA = fields.UUID( description="Mediation record identifier", example=UUIDFour.EXAMPLE, ) MEDIATION_STATE_SCHEMA = fields.Str( description="Mediation state (optional)", required=False, validate=validate.OneOf([ getattr(MediationRecord, m) for m in vars(MediationRecord) if m.startswith("STATE_") ]),
class IdSchema(Schema): id = fields.UUID(required=False) class Meta: unknown = EXCLUDE
class ProductQuerySchema(abstract.AbstractQuerySchema): price_currency = fields.String(data_key="priceCurrency", required=False) price_country = fields.String(data_key="priceCountry", required=False) price_customer_group = fields.UUID(data_key="priceCustomerGroup", required=False) price_channel = fields.UUID(data_key="priceChannel", required=False)
class FileResponseSchema(Schema): id = fields.UUID(required=True)
class AlbumSchema(Schema): id = fields.UUID() name = fields.String() ids = fields.List(fields.UUID()) thumbnail = fields.String(allow_none=True)
class TokenSchema(Schema): token = fields.UUID() expiry = fields.DateTime()
class PluginSchema(Schema): uuid = fields.UUID() title = fields.String() module_name = fields.String() path = fields.String()
def test_uuid_field_deserialization(self): field = fields.UUID() uuid_str = str(uuid.uuid4()) result = field.deserialize(uuid_str) assert isinstance(result, uuid.UUID) assert str(result) == uuid_str
class OrganizationSchema(Schema): uuid = fields.UUID() name = fields.String() server = fields.Integer()
class DuplicateFlowResponseSchema(Schema): id = fields.UUID(required=True, metadata={'description': 'ID of a new flow'})
class CreateBookGenreBodySchema(Schema): """POST book genre body schema for book management.""" book_id = fields.UUID(required=False) secondary_genre_name = fields.String(required=True)