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)
