from sqlalchemy import desc
api = Namespace("dancing_class", description="Classes")
def all_dancing_classes():
return [
d.json() for d in DancingClass.query.order_by(
desc(DancingClass.datetime)).all()
]
model_dancing_class = api.model(
"DancingClass", {
"name": fields.String(required=True),
"datetime": fields.DateTime(required=True),
})
model_dancing_class_person = api.model(
"DancingClassPerson", {
"person_id": fields.Integer(required=True),
"notes": fields.String(required=False),
})
model_dancing_class_couple = api.model(
"DancingClassCouple", {
"person_id": fields.Integer(required=True),
"partner_id": fields.Integer(required=True),
})
model_couple = api.model("Couple", {
"couple_id": fields.Integer(required=True),
})
def test_rfc822_value(self, value, expected):
self.assert_field(fields.DateTime(dt_format="rfc822"), value, expected)
def test_unsupported_format(self):
field = fields.DateTime(dt_format="raw")
self.assert_field_raises(field, datetime.now())
def test_min_as_date(self):
field = fields.DateTime(min=date(1984, 6, 7))
assert "minimum" in field.__schema__
assert field.__schema__["minimum"] == "1984-06-07T00:00:00"
assert "exclusiveMinimum" not in field.__schema__
def test_max_as_datetime(self):
field = fields.DateTime(max=datetime(1984, 6, 7, 1, 2, 0))
assert "maximum" in field.__schema__
assert field.__schema__["maximum"] == "1984-06-07T01:02:00"
assert "exclusiveMaximum" not in field.__schema__
class ArticleModel:
def __init__(self, api):
self.api = api
article_id = fields.Integer(
title="articleId",
description="記事ID",
example=1,
)
title = fields.String(
title="title",
description="記事タイトル",
example="flask-restxの使い方",
required=True,
)
body = fields.String(
title="body",
description="記事本文",
example="hogehoge",
)
created_at = fields.DateTime(
title="createdAt",
description="作成日",
)
created_by = fields.String(
title="createdBy",
description="作成者",
example="山田 太郎",
)
updated_at = fields.DateTime(
title="updatedAt",
description="更新日",
)
updated_by = fields.String(
title="updatedBy",
description="更新者",
example="山田 太郎",
)
def article_post_request_model(self):
return self.api.model(
"Article post request model",
model={
"title": self.title,
"body": self.body,
},
)
def article_put_request_model(self):
return self.api.model(
"Article put request model",
model={
"title": self.title,
"body": self.body,
},
)
def article_get_response_model(self):
return self.api.model(
"Article get response model",
model={
"ariticleId": self.article_id,
"title": self.title,
"body": self.body,
"createdAt": self.created_at,
"createdBy": self.created_by,
"updatedAt": self.updated_at,
"updatedBy": self.updated_by,
},
)
default=1,
help="Page number")
parser.add_argument("per_page",
type=int,
required=False,
default=10,
help="Page size")
# Response marshalling
object = object_ns.model(
"Object",
{
"name": fields.String(description="Object name."),
"description": fields.String(description="Object description."),
"last_updated":
fields.DateTime(description="Updated time of the object."),
"json_object": fields.Raw(description="The object."),
},
)
metadata = object_ns.model(
"metadata",
{
"count":
fields.String(readonly=True,
description="Total number of the items of the data."),
"offset":
fields.String(
readonly=True,
description=
"Position of the first element of the data from the total data amount.",
from flask_restx import Namespace, Resource, fields
from app.db import tweet_repository
from app.models import Tweet
api = Namespace('tweets') # Base route
json_tweet = api.model(
'Tweet', {
'id': fields.Integer(required=True),
'text': fields.String(required=True, min_length=1),
'created_at': fields.DateTime(required=True),
})
json_new_tweet = api.model(
'New tweet',
{
'text': fields.String(required=True,
min_length=1), # Don't allow empty string
})
@api.route('/<int:tweet_id>') # route extension (ie: /tweets/<int:id>)
@api.response(404, 'Tweet not found')
@api.param('tweet_id', 'The tweet unique identifier')
class TweetResource(Resource):
@api.marshal_with(json_tweet) # Used to control JSON response format
def get(self, tweet_id): # GET method
tweet = tweet_repository.get(tweet_id)
if tweet is None:
api.abort(
404
'username':
fields.String(required=True, description='The user username'),
'videoname':
fields.String(
required=True,
description='The videoname the user did the experience with'),
'videotype':
fields.String(
required=True,
description='The videoname type (either continuous or intermittent)'
),
'input':
fields.String(required=True, description='The user input'),
'dateExperience':
fields.DateTime(
required=True,
description='The date which the user took the experience')
})
EPFeelingsScreenshots = api.model(
'EPFeelingScreenshots', {
'username':
fields.String(required=True, description='The user username'),
'feeling':
fields.String(
required=True,
description='The feeling associated with the screenshot'),
'source':
fields.String(required=True, description='The source of the image'),
})
EPReactionsScreenshots = api.model(
'EPReactionScreenshots', {
from backend.common.db.repository.patient_repository import PatientRepository
from backend.heparin.heparin_dosage import recommended_heparin, HeparinRecommendation
from backend.insulin.insulin_dosage import recommended_insulin
logger = logging.getLogger(__name__)
# create the namespace
namespace = Namespace('recommendation')
heparin_recommendation_out = {
'actual_heparin_continuous_dosage': fields.Float(required=True, description='Actual heparin continuous dosage.'),
'previous_heparin_continuous_dosage': fields.Float(required=True,
description='Previous heparin continuous dosage.'),
'actual_heparin_bolus_dosage': fields.Float(required=True, description='Actual heparin bolus dosage.'),
'previous_heparin_bolus_dosage': fields.Float(required=True, description='Previous heparin bolus dosage.'),
'next_remainder': fields.DateTime(required=True, description='Next reminder.'),
'doctor_warning': fields.String(required=False, description='Doctor warning.'),
}
def heparin_recommendation_to_out(
heparin_recommendation: HeparinRecommendation,
previous_heparin_continuous_dosage: float,
previous_heparin_bolus_dosage: float
):
return {
'actual_heparin_continuous_dosage': float(heparin_recommendation.heparin_continuous_dosage),
'previous_heparin_continuous_dosage': previous_heparin_continuous_dosage,
'actual_heparin_bolus_dosage': float(heparin_recommendation.heparin_bolus_dosage),
'previous_heparin_bolus_dosage': previous_heparin_bolus_dosage,
'next_remainder': heparin_recommendation.next_remainder.isoformat(),
parser.add_argument("code_id",
type=str,
help="The id of the code (repository).")
parser.add_argument("page", type=int, default=1, location="args")
parser.add_argument("per_page", type=int, location="args")
# Response marshalling
code = code_ns.model(
"Code",
{
"code_id": fields.String(
description="The id of the code (repository).", ),
"repository_url":
fields.String(description="The URL of the repository."),
"scm_type": fields.String(description="The type of the repository."),
"last_updated": fields.DateTime(description="Last updated date."),
},
)
code_list_fields = code_ns.model(
"CodesList",
{
"metadata":
fields.Raw(
description=
"Metada (number of page, current page, total number of items)."),
"data":
fields.List(fields.Nested(code), description="List of items."),
},
)
api = Namespace("user", description="User administration related operations")
user = api.model(
"User",
{
"id": fields.String(required=True, description="The user identifier"),
"firstname": fields.String(required=True, description="The user first name"),
"lastname": fields.String(required=True, description="The user last name"),
"username": fields.String(required=True, description="The user email/username"),
"gender": fields.String(required=True, description="The user gender"),
"activision_id": fields.String(required=True, description="The user gender"),
"stream_type": fields.String(required=True, description="The user gender"),
"stream_url": fields.String(required=True, description="The user gender"),
"avatar_url": fields.String(required=True, description="The user gender"),
"dob": fields.Date(required=False, description="The user date of birth"),
"registration_date": fields.DateTime(required=False, description="The user date of registration"),
},
)
create_user = reqparse.RequestParser()
create_user.add_argument("firstname", type=str, required=True, location='json')
create_user.add_argument("lastname", type=str, required=True, location='json')
create_user.add_argument("username", type=str, required=True, location='json')
create_user.add_argument("gender", type=str, required=True, location='json')
create_user.add_argument("password", type=str, required=True, location='json')
create_user.add_argument("dob", type=str, required=True, location='json', help='YYYY-MM-DD')
@api.route("/")
class CurrentUser(Resource):
api = Namespace(
'books',
path='/',
description='Book API',
)
book_model = api.model(
'Book', {
'id': fields.String(),
'name': fields.String(),
'rating': fields.Float(),
'authorId': fields.String(),
'collaboratorId': fields.String(),
'published': fields.Date(),
'created': fields.DateTime(),
'updated': fields.DateTime(),
'author': fields.Raw(),
'collaborator': fields.Raw(),
'genre': fields.Raw(),
})
book_schema = BookSchema()
books_many_schema = BookSchema(many=True)
@api.route('/book/<bookId>', endpoint='book_by_id') # noqa: E501
class BookResource(Resource): # type: ignore
@api.doc(id='get-book-by-id',
responses={
401: 'Unauthorised',
from werkzeug.exceptions import BadRequest
from typing import Optional
from ..models.Bill import Bill
from ..models.Category import Category
from ..models.User import User
from .api import api
api = Namespace("bills", description="Bill related operations")
bill = api.model('Bill', {
'amount': fields.Integer(required=True, description='Amount'),
'caregory_id': fields.Integer(required=True, description='category'),
'user_id': fields.Integer(required=True, description='user'),
'date': fields.DateTime(required=False, description='date'),
})
@api.route("/<int:bill_id>")
@api.doc(
responses={404: "Bill not found"},
params={"bill_id": "The Bill ID"})
class BillResource(Resource):
@api.marshal_with(bill, code=201)
def get(self, bill_id):
"""
Get a list of all bills
"""
bills = Bill.find_by_date(date)
from app.extensions.api import api_v1 as api
dict_schema = {
'sessionId':
f_fields.Integer(required=True, description=''),
'beamLineSetupId':
f_fields.Integer(required=False, description=''),
'proposalId':
f_fields.Integer(required=True, description=''),
'beamCalendarId':
f_fields.Integer(required=False, description=''),
'projectCode':
f_fields.String(required=False, description=''),
'startDate':
f_fields.DateTime(required=False, description=''),
'endDate':
f_fields.DateTime(required=False, description=''),
'beamLineName':
f_fields.String(required=False, description=''),
'scheduled':
f_fields.Integer(required=False, description=''),
'nbShifts':
f_fields.Integer(required=False, description=''),
'comments':
f_fields.String(required=False, description=''),
'beamLineOperator':
f_fields.String(required=False, description=''),
'bltimeStamp':
f_fields.DateTime(required=True, description=''),
'visit_number':
dict_schema = {
'phasingProgramRunId':
f_fields.Integer(required=True,
description='Primary key (auto-incremented)'),
'phasingCommandLine':
f_fields.String(required=False, description='Command line for phasing'),
'phasingPrograms':
f_fields.String(required=False,
description='Phasing programs (comma separated)'),
'phasingStatus':
f_fields.Integer(required=False, description='success (1) / fail (0)'),
'phasingMessage':
f_fields.String(required=False, description='warning, error,...'),
'phasingStartTime':
f_fields.DateTime(required=False, description='Processing start time'),
'phasingEndTime':
f_fields.DateTime(required=False, description='Processing end time'),
'phasingEnvironment':
f_fields.String(required=False, description='Cpus, Nodes,...'),
'recordTimeStamp':
f_fields.DateTime(required=False, description=''),
}
class PhasingProgramRunSchema(Schema):
"""Marshmallows schema class representing PhasingProgramRun table"""
phasingProgramRunId = ma_fields.Integer()
phasingCommandLine = ma_fields.String()
phasingPrograms = ma_fields.String()
from flask_restx import fields
from core.api import api
beer_model = api.model(
'Beer', {
'id':
fields.Integer(readOnly=True,
description='The unique identifier of a beer.'),
'name':
fields.String(required=True, description='Name of the beer.'),
'sku':
fields.String(required=True, description='Stock Keeping Unit'),
'price':
fields.String(required=True,
description='Price of a single unit /bottle/ of beer.'),
'image':
fields.String(required=True, description='Image containing the beer.'),
'time_created':
fields.DateTime(required=True,
description='Moment, in which the beer was created.'),
'time_modified':
fields.DateTime(
required=True,
description='Moment, in which the beer was last modified.'),
})
from flask_restx import Namespace, Resource, fields
from app import db
from app.models import Tweet
api = Namespace('tweets')
tweet = api.model(
'Tweet', {
'id':
fields.Integer(readonly=True,
description='The tweet unique identifier'),
'text':
fields.String(required=True, description='The tweet message'),
'created_at':
fields.DateTime(readonly=True, description='The creation date')
})
@api.route('/')
class TweetResource(Resource):
@api.doc('get_tweet')
@api.marshal_list_with(tweet)
def get(self):
return db.session.query(Tweet).all(), 200
@api.doc('create_tweet')
@api.expect(tweet)
@api.marshal_with(tweet, code=201)
def post(self):
"""
__license__ = "LGPLv3+"
from marshmallow import Schema, fields as ma_fields
from flask_restx import fields as f_fields
from marshmallow_jsonschema import JSONSchema
from app.extensions.api import api_v1 as api
dict_schema = {
'autoProcProgramMessageId':
f_fields.Integer(required=True, description=''),
'autoProcProgramId':
f_fields.Integer(required=False, description=''),
'recordTimeStamp':
f_fields.DateTime(required=True, description=''),
'severity':
f_fields.String(required=False, description='enum(ERROR,WARNING,INFO)'),
'message':
f_fields.String(required=False, description=''),
'description':
f_fields.String(required=False, description=''),
}
class AutoProcProgramMessageSchema(Schema):
"""Marshmallows schema class representing AutoProcProgramMessage table"""
autoProcProgramMessageId = ma_fields.Integer()
autoProcProgramId = ma_fields.Integer()
recordTimeStamp = ma_fields.DateTime()
def __init__(self, ns_auth: Namespace, ns_teams: Namespace):
user_register_model = {
'email':
fields.String(max_length=EMAIL_MAX_LENGTH, required=True),
'name':
fields.String(max_length=NAME_MAX_LENGTH, required=True),
'tempo':
fields.Integer(min=0,
required=True,
description='Runners tempo, in secs/km'),
'password':
fields.String(max_length=PASSWORD_MAX_LENGTH, required=True)
}
user_reset_model = {
'email': fields.String(max_length=EMAIL_MAX_LENGTH, required=True)
}
registration_error_keys = {}
for key in user_register_model:
registration_error_keys[key] = fields.List(fields.String,
attribute=key)
self.user_login = ns_auth.model(
'LoginRequest', {
'email':
fields.String(max_length=EMAIL_MAX_LENGTH, required=True),
'password':
fields.String(max_length=PASSWORD_MAX_LENGTH, required=True)
})
self.user_register = ns_auth.model('RegisterRequest',
user_register_model)
self.user_reset = ns_auth.model('PasswordResetRequest',
user_reset_model)
self.user = ns_auth.model(
'User', {
'id': fields.String,
'email': fields.String(max_length=EMAIL_MAX_LENGTH,
required=True),
'name': fields.String(max_length=NAME_MAX_LENGTH,
required=True),
'tempo': fields.Float(min=0, required=True)
})
self.import_model = ns_auth.model(
'Import', {'connection': fields.String(required=True)})
self.jwt_response = ns_auth.model(
'JWTResponse', {
'access_token': fields.String(required=True),
'refresh_token': fields.String,
'expires_at': fields.Integer(required=True),
'user': fields.Nested(self.user)
})
self.jwt_refresh_response = ns_auth.model(
'JWTRefreshResponse', {
'access_token': fields.String(required=True),
'expires_at': fields.DateTime(required=True)
})
self.error = ns_auth.model('ErrorResponse', {"msg": fields.String()})
self.security_bad_request = ns_auth.model('BadSecurityResponse',
registration_error_keys)
self.response_meta = ns_auth.model('ResponseMetadata',
{'code': fields.Integer})
self.registration_error_keys = ns_auth.model('RegistrationErrorKeys',
registration_error_keys)
self.registration_response_body = ns_auth.model(
'RegistrationResponseBody', {
'csrf_token': fields.String,
'user': fields.Nested(self.user),
'errors': fields.Nested(self.registration_error_keys)
})
self.registration_response = ns_auth.model(
'RegistrationResponse', {
'meta': fields.Nested(self.response_meta),
'response': fields.Nested(self.registration_response_body)
})
self.stage = ns_teams.model(
name='Stage',
model={
'index':
fields.Integer(min=0, max=NUMBER_OF_STAGES - 1, required=True),
'email':
fields.String(max_length=EMAIL_MAX_LENGTH, required=True),
'estimated_time':
fields.Integer(min=0),
'real_time':
fields.Integer(min=0),
'length':
fields.Integer(min=0),
'id':
fields.String
})
self.team = ns_teams.model(
'Team', {
'id':
fields.String,
'name':
fields.String(max_length=TEAM_NAME_MAX_LENGTH, required=True),
'donation':
fields.Float(min=0),
'average_tempo':
fields.Integer(
min=0,
description='Average tempo for so far completed stages'),
'stages_completed':
fields.Integer(min=0, max=NUMBER_OF_STAGES),
'start':
fields.Integer(
min=0,
max=DAY_SECONDS,
description=
"Team's starting time of day, in seconds since midnight"),
'members':
fields.List(fields.String(max_length=EMAIL_MAX_LENGTH),
required=True),
'stages':
fields.List(fields.Nested(self.stage))
})
self.team_list = ns_teams.model(
'TeamsList', {'teams': fields.List(fields.Nested(self.team))})
self.user_list = ns_teams.model(
'UserList', {'users': fields.List(fields.Nested(self.user))})
self.edit_stages_request = ns_teams.model(
'EditStagesRequest',
{'stages': fields.List(fields.Nested(self.stage))})
self.add_members_request = ns_teams.model(
'AddMembersRequest', {
'members':
fields.List(fields.String(max_length=EMAIL_MAX_LENGTH),
required=True)
})
self.vapid_public_key = ns_auth.model(
'VAPIDKey', {'public_key': fields.String(required=True)})
self.push_subscription_keys = ns_auth.model('PushSubscriptionKeys', {
'p256dh': fields.String(),
'auth': fields.String()
})
self.push_subscription = ns_auth.model(
'PushSubscription', {
'endpoint': fields.String(required=True),
'expiration_time': fields.Integer(),
'keys': fields.Nested(self.push_subscription_keys)
})
def test_defaults(self):
field = fields.DateTime()
assert not field.required
assert field.__schema__ == {"type": "string", "format": "date-time"}
self.assert_field(field, None, None)
'resolutionLimitLow': f_fields.Float(required=False, description='Low resolution limit'),
'resolutionLimitHigh': f_fields.Float(required=False, description='High resolution limit'),
'rMerge': f_fields.Float(required=False, description='Rmerge'),
'rMeasWithinIPlusIMinus': f_fields.Float(required=False, description='Rmeas (within I+/I-)'),
'rMeasAllIPlusIMinus': f_fields.Float(required=False, description='Rmeas (all I+ & I-)'),
'rPimWithinIPlusIMinus': f_fields.Float(required=False, description='Rpim (within I+/I-) '),
'rPimAllIPlusIMinus': f_fields.Float(required=False, description='Rpim (all I+ & I-)'),
'fractionalPartialBias': f_fields.Float(required=False, description='Fractional partial bias'),
'nTotalObservations': f_fields.Integer(required=False, description='Total number of observations'),
'nTotalUniqueObservations': f_fields.Integer(required=False, description='Total number unique'),
'meanIOverSigI': f_fields.Float(required=False, description='Mean((I)/sd(I))'),
'completeness': f_fields.Float(required=False, description='Completeness'),
'multiplicity': f_fields.Float(required=False, description='Multiplicity'),
'anomalousCompleteness': f_fields.Float(required=False, description='Anomalous completeness'),
'anomalousMultiplicity': f_fields.Float(required=False, description='Anomalous multiplicity'),
'recordTimeStamp': f_fields.DateTime(required=False, description='Creation or last update date/time'),
'anomalous': f_fields.Integer(required=False, description='boolean type:0 noanoum - 1 anoum'),
'ccHalf': f_fields.Float(required=False, description='information from XDS'),
'ccAnomalous': f_fields.Float(required=False, description=''),
}
class AutoProcScalingStatisticsSchema(Schema):
"""Marshmallows schema class representing AutoProcScalingStatistics table"""
autoProcScalingStatisticsId = ma_fields.Integer()
autoProcScalingId = ma_fields.Integer()
scalingStatisticsType = ma_fields.String()
comments = ma_fields.String()
resolutionLimitLow = ma_fields.Float()
resolutionLimitHigh = ma_fields.Float()
rMerge = ma_fields.Float()
def test_max(self):
field = fields.DateTime(max="1984-06-07T00:00:00")
assert "maximum" in field.__schema__
assert field.__schema__["maximum"] == "1984-06-07T00:00:00"
assert "exclusiveMaximum" not in field.__schema__
# Response marshalling
release = release_ns.model(
"Release",
{
"release_id":
fields.String(description="The id of the release.", ),
"version":
fields.String(description="The version of the release."),
"changes":
fields.String(description="The changes related to the release."),
"release_url":
fields.String(description="The URL of the release."),
"project_id":
fields.String(description="The id of the project."),
"published_at":
fields.DateTime(description="Date of publication of the release."),
},
)
release_list_fields = release_ns.model(
"ReleasesList",
{
"metadata":
fields.Raw(
description=
"Metada (number of page, current page, total number of items)."),
"data":
fields.List(fields.Nested(release), description="List of items."),
},
)
def test_max_exclusive(self):
field = fields.DateTime(max="1984-06-07T00:00:00", exclusiveMax=True)
assert "maximum" in field.__schema__
assert field.__schema__["maximum"] == "1984-06-07T00:00:00"
assert "exclusiveMaximum" in field.__schema__
assert field.__schema__["exclusiveMaximum"] is True
cpe_fields = {}
cpe_fields['cpe_23_uri'] = fields.String(attribute='cpe_23_uri')
cpe_fields['vendor'] = fields.String(attribute='vendor')
cpe_fields['product'] = fields.String(attribute='product')
cpe_fields['vulnerable'] = fields.Boolean(attribute='vulnerable')
cvssv3_fields = {}
cvssv3_fields['version'] = fields.String(attribute='version')
cvssv3_fields['vector_string'] = fields.String(attribute='vector_string')
cvssv3_fields['attack_vector'] = fields.String(attribute='attack_vector')
cvssv3_fields['cvss3_score'] = fields.Float(attribute=('cvss3_score'))
cve_fields = {}
cve_fields['cve_id'] = fields.String(attribute='cve_id')
cve_fields['description'] = fields.String(attribute='description')
cve_fields['published_date'] = fields.DateTime(attribute='published_date')
cve_fields['last_modified'] = fields.DateTime(attribute='last_modified')
model_cotroller_1 = {}
model_cotroller_1['cve_id'] = fields.String(attribute='cve_id')
model_cotroller_1['description'] = fields.String(attribute='description')
model_cotroller_1['published_date'] = fields.DateTime(
attribute='published_date')
model_cotroller_1['last_modified'] = fields.DateTime(attribute='last_modified')
model_cotroller_1['cpes'] = fields.List(fields.Nested(cpe_fields))
model_cotroller_1['cvssv3'] = fields.Nested(cvssv3_fields)
model_cotroller_2 = {}
model_cotroller_2['cves'] = fields.List(fields.Nested(cve_fields))
def test_iso8601_value(self, value, expected):
self.assert_field(fields.DateTime(dt_format="iso8601"), value,
expected)
fields.String(required=True, description="Unique exercise name"),
"description":
fields.String(required=True, description="Description", default=False),
"is_public":
fields.Boolean(
required=True,
description="Is this riff exercise visible to everyone?",
default=False),
"root_key":
fields.String(
required=True,
description=
"Root key of exercise (for printing purposes in the future)",
default=False),
"created_at":
fields.DateTime(),
"created_by":
fields.String(),
"modified_at":
fields.DateTime(),
"gravatar_image":
fields.String(),
"tags":
fields.Nested(tag_info_marshaller),
"stars":
fields.Integer(),
"instrument_key":
fields.String(),
"instruments":
fields.List(fields.String),
},
def test_unsupported_value_format(self):
field = fields.DateTime(dt_format="raw")
self.assert_field_raises(field, "xxx")
'undulatorType3': f_fields.String(required=False, description=''), 'focalSpotSizeAtSample': f_fields.Float(required=False, description=''), 'focusingOptic': f_fields.String(required=False, description=''), 'beamDivergenceHorizontal': f_fields.Float(required=False, description=''), 'beamDivergenceVertical': f_fields.Float(required=False, description=''), 'polarisation': f_fields.Float(required=False, description=''), 'monochromatorType': f_fields.String(required=False, description=''), 'setupDate': f_fields.DateTime(required=False, description=''), 'synchrotronName': f_fields.String(required=False, description=''), 'maxExpTimePerDataCollection': f_fields.String(required=False, description=''), 'maxExposureTimePerImage': f_fields.Float(required=False, description='unit: seconds'), 'minExposureTimePerImage': f_fields.String(required=False, description=''), 'goniostatMaxOscillationSpeed': f_fields.String(required=False, description=''), 'goniostatMaxOscillationWidth': f_fields.String(required=False, description='unit: degrees'), 'goniostatMinOscillationWidth': f_fields.String(required=False, description=''), 'maxTransmission':
