Use the Schema Registry#
This guide shows how to register configuration schemas and use the SchemaRegistry to validate configuration and generate JSON Schemas.
Create a Registry#
When creating a new schema registry it will be empty. Schemas can be registered manually or automatically by using the discovery functionality which will be explained later in this guide.
from pyaml.validation import SchemaRegistry
registry = SchemaRegistry()
print(registry)
SchemaRegistry({})
The registry is implemented as a singleton which means the same object will be returned every time you create a new instance of it during the same session. Schemas therefore only have to be registered once per session.
Register a Schema#
There are two ways to register a schema:
Use the
registermethodUse the
register_schemadecorator to automatically register schemas when a module is loadedThe decorator can be used in two ways: dynamically generating the schema from the class constructor or by explicitly declaring a schema too use for the class.
Note: a decorator only runs when a module is imported. If you use the
register_schemadecorator in a module that is not imported the schema will not be registered.
The different ways to use the decorator is explained below.
Register a Dynamic Schema#
The decorator generates a ConfigurationSchema and registers it in the schema registry using the class’s fully qualified path.
from pyaml.validation import register_schema
@register_schema
class Magnet:
def __init__(self, length: float):
self.length = length
The schema is now visible in the registry. In this case the schema will get the path __main__.Magnet since the class was declared directly in the script. For other classes it will be of the form package.module.Class.
You can use describe to get pretty output of the fields in the schema. ConfigurationSchema inherits from Pydantic BaseModel so the functionality of that class is also available. See Pydantic’s documentation for details.
# See the content of the registry
print(registry)
# See the fields in the model
print(registry["__main__.Magnet"].describe())
SchemaRegistry(
'__main__.Magnet': __main__.MagnetConfigurationSchema,
)
MagnetConfigurationSchema(
class_path: str — Fully qualified class path.
length: float
)
Register an Explicit Schema#
Define a ConfigurationSchema explicitly when you need more control over the configuration fields or validation rules. The functionality of Pydantic is available when defining the schema.
The explicit schema must inherit from ConfigurationSchema since that defined the minimum required fields for all items in the registry.
from pyaml.validation import ConfigurationSchema, register_schema
class DifferentMagnetSchema(ConfigurationSchema):
length: float
@register_schema(DifferentMagnetSchema)
class DifferentMagnet:
def __init__(self, length: float):
self.length = length
Bot schemas are now available in the registry.
print(registry)
SchemaRegistry(
'__main__.DifferentMagnet': __main__.DifferentMagnetSchema,
'__main__.Magnet': __main__.MagnetConfigurationSchema,
)
Automatically Discover Schemas#
Since registration only happens when the modules containing decorated classes are imported, a discover method is available to automatically scan packages and register the schemas in the package.
from pyaml.validation import SchemaRegistry
registry = SchemaRegistry()
# Clear the registry to remove the schemas that were manually registered
registry.clear()
# Automatically discover and register all schemas
registry.discover()
# Print the content of the registry
print(registry)
SchemaRegistry(
'abc.ABC': abc.ABCConfigurationSchema,
'pyaml.accelerator.Accelerator': pyaml.accelerator.AcceleratorConfigurationSchema,
'pyaml.arrays.array.ArrayConfig': pyaml.arrays.array.ArrayConfigConfigurationSchema,
'pyaml.arrays.bpm.BPM': pyaml.arrays.bpm.BPMConfigurationSchema,
'pyaml.arrays.cfm_magnet.CombinedFunctionMagnet': pyaml.arrays.cfm_magnet.CombinedFunctionMagnetConfigurationSchema,
'pyaml.arrays.element.Element': pyaml.arrays.element.ElementConfigurationSchema,
'pyaml.arrays.magnet.Magnet': pyaml.arrays.magnet.MagnetConfigurationSchema,
'pyaml.arrays.serialized_magnet.SerializedMagnets': pyaml.arrays.serialized_magnet.SerializedMagnetsConfigurationSchema,
'pyaml.bpm.bpm.BPM': pyaml.bpm.bpm.BPMConfigurationSchema,
'pyaml.common.element.Element': pyaml.common.element.ElementConfigurationSchema,
'pyaml.common.holders.element_holder.ElementHolder': pyaml.common.holders.element_holder.ElementHolderConfigurationSchema,
'pyaml.control.controlsystem.ControlSystem': pyaml.control.controlsystem.ControlSystemConfigurationSchema,
'pyaml.control.deviceaccess.DeviceAccess': pyaml.control.deviceaccess.DeviceAccessConfigurationSchema,
'pyaml.diagnostics.atune_monitor.ABetatronTuneMonitor': pyaml.diagnostics.atune_monitor.ABetatronTuneMonitorConfigurationSchema,
'pyaml.diagnostics.tune_monitor.BetatronTuneMonitor': pyaml.diagnostics.tune_monitor.BetatronTuneMonitorConfigurationSchema,
'pyaml.lattice.attribute_linker.PyAtAttributeElementsLinker': pyaml.lattice.attribute_linker.PyAtAttributeElementsLinkerConfigurationSchema,
'pyaml.lattice.lattice_elements_linker.LatticeElementsLinker': pyaml.lattice.lattice_elements_linker.LatticeElementsLinkerConfigurationSchema,
'pyaml.lattice.lattice_elements_linker.LinkerConfigModel': pyaml.lattice.lattice_elements_linker.LinkerConfigModelConfigurationSchema,
'pyaml.lattice.simulator.Simulator': pyaml.lattice.simulator.SimulatorConfigurationSchema,
'pyaml.magnet.cfm_magnet.CombinedFunctionMagnet': pyaml.magnet.cfm_magnet.CombinedFunctionMagnetConfigurationSchema,
'pyaml.magnet.csvcurve.CSVCurve': pyaml.magnet.csvcurve.CSVCurveConfigurationSchema,
'pyaml.magnet.csvmatrix.CSVMatrix': pyaml.magnet.csvmatrix.CSVMatrixConfigurationSchema,
'pyaml.magnet.curve.Curve': pyaml.magnet.curve.CurveConfigurationSchema,
'pyaml.magnet.hcorrector.HCorrector': pyaml.magnet.hcorrector.HCorrectorConfigurationSchema,
'pyaml.magnet.identity_cfm_model.IdentityCFMagnetModel': pyaml.magnet.identity_cfm_model.IdentityCFMagnetModelConfigurationSchema,
'pyaml.magnet.identity_model.IdentityMagnetModel': pyaml.magnet.identity_model.IdentityMagnetModelConfigurationSchema,
'pyaml.magnet.inline_curve.InlineCurve': pyaml.magnet.inline_curve.InlineCurveConfigurationSchema,
'pyaml.magnet.inline_matrix.InlineMatrix': pyaml.magnet.inline_matrix.InlineMatrixConfigurationSchema,
'pyaml.magnet.linear_cfm_model.LinearCFMagnetModel': pyaml.magnet.linear_cfm_model.LinearCFMagnetModelConfigurationSchema,
'pyaml.magnet.linear_model.LinearMagnetModel': pyaml.magnet.linear_model.LinearMagnetModelConfigurationSchema,
'pyaml.magnet.linear_serialized_model.LinearSerializedMagnetModel': pyaml.magnet.linear_serialized_model.LinearSerializedMagnetModelConfigurationSchema,
'pyaml.magnet.magnet.Magnet': pyaml.magnet.magnet.MagnetConfigurationSchema,
'pyaml.magnet.matrix.Matrix': pyaml.magnet.matrix.MatrixConfigurationSchema,
'pyaml.magnet.model.MagnetModel': pyaml.magnet.model.MagnetModelConfigurationSchema,
'pyaml.magnet.octupole.Octupole': pyaml.magnet.octupole.OctupoleConfigurationSchema,
'pyaml.magnet.quadrupole.Quadrupole': pyaml.magnet.quadrupole.QuadrupoleConfigurationSchema,
'pyaml.magnet.serialized_magnet.SerializedMagnets': pyaml.magnet.serialized_magnet.SerializedMagnetsConfigurationSchema,
'pyaml.magnet.sextupole.Sextupole': pyaml.magnet.sextupole.SextupoleConfigurationSchema,
'pyaml.magnet.skewoctu.SkewOctu': pyaml.magnet.skewoctu.SkewOctuConfigurationSchema,
'pyaml.magnet.skewquad.SkewQuad': pyaml.magnet.skewquad.SkewQuadConfigurationSchema,
'pyaml.magnet.skewsext.SkewSext': pyaml.magnet.skewsext.SkewSextConfigurationSchema,
'pyaml.magnet.spline_model.SplineMagnetModel': pyaml.magnet.spline_model.SplineMagnetModelConfigurationSchema,
'pyaml.magnet.vcorrector.VCorrector': pyaml.magnet.vcorrector.VCorrectorConfigurationSchema,
'pyaml.rf.rf_plant.RFPlant': pyaml.rf.rf_plant.RFPlantConfigurationSchema,
'pyaml.rf.rf_transmitter.RFTransmitter': pyaml.rf.rf_transmitter.RFTransmitterConfigurationSchema,
'pyaml.tuning_tools.bba.BBA': pyaml.tuning_tools.bba.BBAConfigurationSchema,
'pyaml.tuning_tools.bba2.BBA2': pyaml.tuning_tools.bba2.BBA2ConfigurationSchema,
'pyaml.tuning_tools.chromaticity.Chromaticity': pyaml.tuning_tools.chromaticity.ChromaticityConfigurationSchema,
'pyaml.tuning_tools.chromaticity_monitor.ChromaticityMonitor': pyaml.tuning_tools.chromaticity_monitor.ChromaticityMonitorConfigurationSchema,
'pyaml.tuning_tools.chromaticity_response_matrix.ChromaticityResponseMatrix': pyaml.tuning_tools.chromaticity_response_matrix.ChromaticityResponseMatrixConfigurationSchema,
'pyaml.tuning_tools.dispersion.Dispersion': pyaml.tuning_tools.dispersion.DispersionConfigurationSchema,
'pyaml.tuning_tools.measurement_tool.MeasurementTool': pyaml.tuning_tools.measurement_tool.MeasurementToolConfigurationSchema,
'pyaml.tuning_tools.orbit.Orbit': pyaml.tuning_tools.orbit.OrbitConfigurationSchema,
'pyaml.tuning_tools.orbit_response_matrix.OrbitResponseMatrix': pyaml.tuning_tools.orbit_response_matrix.OrbitResponseMatrixConfigurationSchema,
'pyaml.tuning_tools.orbit_response_matrix_data.OrbitResponseMatrixData': pyaml.tuning_tools.orbit_response_matrix_data.OrbitResponseMatrixDataConfigurationSchema,
'pyaml.tuning_tools.response_matrix_data.ResponseMatrixData': pyaml.tuning_tools.response_matrix_data.ResponseMatrixDataConfigurationSchema,
'pyaml.tuning_tools.tune.Tune': pyaml.tuning_tools.tune.TuneConfigurationSchema,
'pyaml.tuning_tools.tune_response_matrix.TuneResponseMatrix': pyaml.tuning_tools.tune_response_matrix.TuneResponseMatrixConfigurationSchema,
'pyaml.tuning_tools.tuning_tool.TuningTool': pyaml.tuning_tools.tuning_tool.TuningToolConfigurationSchema,
'pyaml.validation.validation_models.DynamicValidation': pyaml.validation.validation_models.DynamicValidationConfigurationSchema,
'pyaml_cs_oa.catalog.Catalog': pyaml_cs_oa.catalog.CatalogConfigurationSchema,
'pyaml_cs_oa.controlsystem.OphydAsyncControlSystem': pyaml_cs_oa.controlsystem.OphydAsyncControlSystemConfigurationSchema,
'pyaml_cs_oa.dynamic_catalog.DynamicCatalog': pyaml_cs_oa.dynamic_catalog.DynamicCatalogConfigurationSchema,
'pyaml_cs_oa.epicsR.EpicsR': pyaml_cs_oa.epicsR.EpicsRConfigurationSchema,
'pyaml_cs_oa.epicsRW.EpicsRW': pyaml_cs_oa.epicsRW.EpicsRWConfigurationSchema,
'pyaml_cs_oa.epicsW.EpicsW': pyaml_cs_oa.epicsW.EpicsWConfigurationSchema,
'pyaml_cs_oa.float_signal.FloatSignalContainer': pyaml_cs_oa.float_signal.FloatSignalContainerConfigurationSchema,
'pyaml_cs_oa.signal.OASignal': pyaml_cs_oa.signal.OASignalConfigurationSchema,
'pyaml_cs_oa.static_catalog.StaticCatalog': pyaml_cs_oa.static_catalog.StaticCatalogConfigurationSchema,
'pyaml_cs_oa.static_catalog_entry.StaticCatalogEntry': pyaml_cs_oa.static_catalog_entry.StaticCatalogEntryConfigurationSchema,
'pyaml_cs_oa.tangoAtt.TangoAtt': pyaml_cs_oa.tangoAtt.TangoAttConfigurationSchema,
'pyaml_cs_oa.types.EpicsConfigR': pyaml_cs_oa.types.EpicsConfigRConfigurationSchema,
'pyaml_cs_oa.types.EpicsConfigRW': pyaml_cs_oa.types.EpicsConfigRWConfigurationSchema,
'pyaml_cs_oa.types.EpicsConfigW': pyaml_cs_oa.types.EpicsConfigWConfigurationSchema,
'pyaml_cs_oa.types.TangoConfigAtt': pyaml_cs_oa.types.TangoConfigAttConfigurationSchema,
'typing.Any': typing.AnyConfigurationSchema,
)
Browse the Registry#
The registry also supports common mapping operations. Class paths are the keys and registered schema classes are the values. See the API documentation for all available methods.
Use get() to retrieve the schema for a class path. It returns None when the path is not registered.
schema = registry.get("pyaml.magnet.quadrupole.Quadrupole")
print(schema.describe())
QuadrupoleConfigurationSchema(
class_path: str — Fully qualified class path.
name: str
model: pyaml.magnet.model.MagnetModelConfigurationSchema | None
lattice_names: str | None
description: str | None
)
class_path = "pyaml.magnet.quadrupole.Quadrupole"
# Check if the class is in the registry
print(class_path in registry)
True
# Iterate through the registered schemas
print("\nRegistered class paths:")
for path in registry:
print(f"- {path}")
print("\n Registered schema classes:")
for schema in registry.values():
print(f"- {schema.__name__}")
Registered class paths:
- pyaml.bpm.bpm.BPM
- pyaml.common.element.Element
- pyaml.validation.validation_models.DynamicValidation
- pyaml.magnet.model.MagnetModel
- pyaml.magnet.hcorrector.HCorrector
- pyaml.magnet.magnet.Magnet
- pyaml.magnet.octupole.Octupole
- pyaml.magnet.quadrupole.Quadrupole
- pyaml.magnet.sextupole.Sextupole
- pyaml.magnet.skewoctu.SkewOctu
- pyaml.magnet.skewquad.SkewQuad
- pyaml.magnet.skewsext.SkewSext
- pyaml.magnet.vcorrector.VCorrector
- typing.Any
- pyaml.magnet.cfm_magnet.CombinedFunctionMagnet
- pyaml.magnet.serialized_magnet.SerializedMagnets
- pyaml.diagnostics.tune_monitor.BetatronTuneMonitor
- pyaml.diagnostics.atune_monitor.ABetatronTuneMonitor
- pyaml.rf.rf_transmitter.RFTransmitter
- pyaml.rf.rf_plant.RFPlant
- pyaml.tuning_tools.chromaticity_monitor.ChromaticityMonitor
- pyaml.tuning_tools.measurement_tool.MeasurementTool
- pyaml.arrays.array.ArrayConfig
- pyaml.lattice.lattice_elements_linker.LinkerConfigModel
- abc.ABC
- pyaml.lattice.lattice_elements_linker.LatticeElementsLinker
- pyaml.lattice.simulator.Simulator
- pyaml.common.holders.element_holder.ElementHolder
- pyaml.control.controlsystem.ControlSystem
- pyaml.accelerator.Accelerator
- pyaml.arrays.bpm.BPM
- pyaml.arrays.cfm_magnet.CombinedFunctionMagnet
- pyaml.arrays.element.Element
- pyaml.arrays.magnet.Magnet
- pyaml.arrays.serialized_magnet.SerializedMagnets
- pyaml.lattice.attribute_linker.PyAtAttributeElementsLinker
- pyaml.magnet.csvcurve.CSVCurve
- pyaml.magnet.curve.Curve
- pyaml.magnet.csvmatrix.CSVMatrix
- pyaml.magnet.matrix.Matrix
- pyaml.magnet.identity_cfm_model.IdentityCFMagnetModel
- pyaml.magnet.identity_model.IdentityMagnetModel
- pyaml.magnet.inline_curve.InlineCurve
- pyaml.magnet.inline_matrix.InlineMatrix
- pyaml.magnet.linear_cfm_model.LinearCFMagnetModel
- pyaml.magnet.linear_model.LinearMagnetModel
- pyaml.magnet.linear_serialized_model.LinearSerializedMagnetModel
- pyaml.magnet.spline_model.SplineMagnetModel
- pyaml.tuning_tools.bba.BBA
- pyaml.tuning_tools.bba2.BBA2
- pyaml.tuning_tools.response_matrix_data.ResponseMatrixData
- pyaml.tuning_tools.chromaticity.Chromaticity
- pyaml.tuning_tools.tuning_tool.TuningTool
- pyaml.tuning_tools.chromaticity_response_matrix.ChromaticityResponseMatrix
- pyaml.tuning_tools.dispersion.Dispersion
- pyaml.tuning_tools.orbit_response_matrix_data.OrbitResponseMatrixData
- pyaml.tuning_tools.orbit.Orbit
- pyaml.tuning_tools.orbit_response_matrix.OrbitResponseMatrix
- pyaml.tuning_tools.tune.Tune
- pyaml.tuning_tools.tune_response_matrix.TuneResponseMatrix
- pyaml_cs_oa.epicsR.EpicsR
- pyaml_cs_oa.types.EpicsConfigR
- pyaml_cs_oa.types.EpicsConfigW
- pyaml_cs_oa.types.EpicsConfigRW
- pyaml_cs_oa.types.TangoConfigAtt
- pyaml_cs_oa.float_signal.FloatSignalContainer
- pyaml_cs_oa.signal.OASignal
- pyaml.control.deviceaccess.DeviceAccess
- pyaml_cs_oa.epicsRW.EpicsRW
- pyaml_cs_oa.epicsW.EpicsW
- pyaml_cs_oa.tangoAtt.TangoAtt
- pyaml_cs_oa.catalog.Catalog
- pyaml_cs_oa.controlsystem.OphydAsyncControlSystem
- pyaml_cs_oa.dynamic_catalog.DynamicCatalog
- pyaml_cs_oa.static_catalog_entry.StaticCatalogEntry
- pyaml_cs_oa.static_catalog.StaticCatalog
Registered schema classes:
- BPMConfigurationSchema
- ElementConfigurationSchema
- DynamicValidationConfigurationSchema
- MagnetModelConfigurationSchema
- HCorrectorConfigurationSchema
- MagnetConfigurationSchema
- OctupoleConfigurationSchema
- QuadrupoleConfigurationSchema
- SextupoleConfigurationSchema
- SkewOctuConfigurationSchema
- SkewQuadConfigurationSchema
- SkewSextConfigurationSchema
- VCorrectorConfigurationSchema
- AnyConfigurationSchema
- CombinedFunctionMagnetConfigurationSchema
- SerializedMagnetsConfigurationSchema
- BetatronTuneMonitorConfigurationSchema
- ABetatronTuneMonitorConfigurationSchema
- RFTransmitterConfigurationSchema
- RFPlantConfigurationSchema
- ChromaticityMonitorConfigurationSchema
- MeasurementToolConfigurationSchema
- ArrayConfigConfigurationSchema
- LinkerConfigModelConfigurationSchema
- ABCConfigurationSchema
- LatticeElementsLinkerConfigurationSchema
- SimulatorConfigurationSchema
- ElementHolderConfigurationSchema
- ControlSystemConfigurationSchema
- AcceleratorConfigurationSchema
- BPMConfigurationSchema
- CombinedFunctionMagnetConfigurationSchema
- ElementConfigurationSchema
- MagnetConfigurationSchema
- SerializedMagnetsConfigurationSchema
- PyAtAttributeElementsLinkerConfigurationSchema
- CSVCurveConfigurationSchema
- CurveConfigurationSchema
- CSVMatrixConfigurationSchema
- MatrixConfigurationSchema
- IdentityCFMagnetModelConfigurationSchema
- IdentityMagnetModelConfigurationSchema
- InlineCurveConfigurationSchema
- InlineMatrixConfigurationSchema
- LinearCFMagnetModelConfigurationSchema
- LinearMagnetModelConfigurationSchema
- LinearSerializedMagnetModelConfigurationSchema
- SplineMagnetModelConfigurationSchema
- BBAConfigurationSchema
- BBA2ConfigurationSchema
- ResponseMatrixDataConfigurationSchema
- ChromaticityConfigurationSchema
- TuningToolConfigurationSchema
- ChromaticityResponseMatrixConfigurationSchema
- DispersionConfigurationSchema
- OrbitResponseMatrixDataConfigurationSchema
- OrbitConfigurationSchema
- OrbitResponseMatrixConfigurationSchema
- TuneConfigurationSchema
- TuneResponseMatrixConfigurationSchema
- EpicsRConfigurationSchema
- EpicsConfigRConfigurationSchema
- EpicsConfigWConfigurationSchema
- EpicsConfigRWConfigurationSchema
- TangoConfigAttConfigurationSchema
- FloatSignalContainerConfigurationSchema
- OASignalConfigurationSchema
- DeviceAccessConfigurationSchema
- EpicsRWConfigurationSchema
- EpicsWConfigurationSchema
- TangoAttConfigurationSchema
- CatalogConfigurationSchema
- OphydAsyncControlSystemConfigurationSchema
- DynamicCatalogConfigurationSchema
- StaticCatalogEntryConfigurationSchema
- StaticCatalogConfigurationSchema
# Print the number of schemas in the registry
print(f"\nNumber of registered schemas: {len(registry)}")
Number of registered schemas: 76
Validate Configuration#
Configuration data can be validated using the SchemaValidator. It makes use of the schema registry to extract which schema to validate against for a specific class.
For validation to be possible the class must be registered in the schema registry. If the class is not registered, validation will be skipped, a warning given and the data kept unchanged. Beware that this can lead to unexpected errors.
model_path = "pyaml.magnet.identity_model.IdentityMagnetModel"
print(registry.get(model_path))
<class 'pyaml.magnet.identity_model.IdentityMagnetModelConfigurationSchema'>
from pyaml.validation import SchemaRegistry, SchemaValidator
registry = SchemaRegistry()
registry.discover()
configuration = {
"class_path": "pyaml.magnet.quadrupole.Quadrupole",
"name": "QF1",
"description": "This is the QF1 quadrupole magnet."
}
validated = SchemaValidator.validate(configuration)
Validation also handles nested configuration data.
configuration = {
"class_path": "pyaml.magnet.quadrupole.Quadrupole",
"name": "QF1",
"model": {
"class_path": "pyaml.magnet.identity_model.IdentityMagnetModel",
"unit": "1/m",
"physics": ""
},
"description": "This is the QF1 quadrupole magnet."
}
validated = SchemaValidator.validate(configuration)
print(validated)
class_path='pyaml.magnet.quadrupole.Quadrupole' name='QF1' model=IdentityMagnetModelConfigurationSchema(class_path='pyaml.magnet.identity_model.IdentityMagnetModel', powerconverter=None, physics='', unit='1/m') lattice_names=None description='This is the QF1 quadrupole magnet.'
The validated result can also be returned as a dictionary.
from pprint import pprint
validated_dict = SchemaValidator.validate_to_dict(configuration)
pprint(validated_dict )
{'class_path': 'pyaml.magnet.quadrupole.Quadrupole',
'description': 'This is the QF1 quadrupole magnet.',
'lattice_names': None,
'model': {'class_path': 'pyaml.magnet.identity_model.IdentityMagnetModel',
'physics': '',
'powerconverter': None,
'unit': '1/m'},
'name': 'QF1'}
Generate JSON Schema#
The registry can also be used together with the SchemaGenerator to generate JSON Schema to use with external tools.
If a base schema has registered concrete or virtual subclasses, the generated JSON Schema includes those alternatives. This allows editors and other JSON Schema tools to offer the appropriate fields for each configuration type.
from pprint import pprint
from pyaml.validation import SchemaGenerator
json_schema = SchemaGenerator.generate("pyaml.magnet.quadrupole.Quadrupole")
pprint(json_schema)
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.quadrupole.Quadrupole',
'description': 'Fully qualified class path.',
'title': 'Class',
'type': 'string'},
'description': {'default': None,
'title': 'Description',
'type': ['string', 'null']},
'lattice_names': {'default': None,
'title': 'Lattice Names',
'type': ['string', 'null']},
'model': {'anyOf': [{'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.identity_cfm_model.IdentityCFMagnetModel',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'multipoles': {'items': {'type': 'string'},
'title': 'Multipoles',
'type': 'array'},
'physics': {'anyOf': [{'items': {'type': ['string',
'null']},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Physics'},
'powerconverters': {'anyOf': [{'items': {'type': ['string',
'null']},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Powerconverters'},
'units': {'anyOf': [{'items': {'type': 'string'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Units'}},
'required': ['class',
'multipoles'],
'title': 'IdentityCFMagnetModelConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.identity_model.IdentityMagnetModel',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'physics': {'default': None,
'title': 'Physics',
'type': ['string',
'null']},
'powerconverter': {'default': None,
'title': 'Powerconverter',
'type': ['string',
'null']},
'unit': {'default': None,
'title': 'Unit',
'type': ['string',
'null']}},
'required': ['class'],
'title': 'IdentityMagnetModelConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'calibration_factors': {'anyOf': [{'items': {'type': 'number'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Calibration '
'Factors'},
'calibration_offsets': {'anyOf': [{'items': {'type': 'number'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Calibration '
'Offsets'},
'class': {'const': 'pyaml.magnet.linear_cfm_model.LinearCFMagnetModel',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'curves': {'items': {'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.csvcurve.CSVCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'file': {'title': 'File',
'type': 'string'}},
'required': ['class',
'file'],
'title': 'CSVCurveConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.inline_curve.InlineCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'mat': {'items': {'items': {'type': 'number'},
'type': 'array'},
'title': 'Mat',
'type': 'array'}},
'required': ['class',
'mat'],
'title': 'InlineCurveConfigurationSchema',
'type': 'object'}],
'title': 'CurveConfigurationSchema'},
'title': 'Curves',
'type': 'array'},
'hardware_units': {'items': {'type': 'string'},
'title': 'Hardware '
'Units',
'type': 'array'},
'matrix': {'anyOf': [{'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.csvmatrix.CSVMatrix',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'file': {'title': 'File',
'type': 'string'}},
'required': ['class',
'file'],
'title': 'CSVMatrixConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.inline_matrix.InlineMatrix',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'mat': {'items': {'items': {'type': 'number'},
'type': 'array'},
'title': 'Mat',
'type': 'array'}},
'required': ['class',
'mat'],
'title': 'InlineMatrixConfigurationSchema',
'type': 'object'}],
'title': 'MatrixConfigurationSchema'},
{'type': 'null'}],
'default': None},
'multipoles': {'items': {'type': 'string'},
'title': 'Multipoles',
'type': 'array'},
'powerconverters': {'items': {'type': ['string',
'null']},
'title': 'Powerconverters',
'type': 'array'},
'pseudo_factors': {'anyOf': [{'items': {'type': 'number'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Pseudo '
'Factors'},
'pseudo_offsets': {'anyOf': [{'items': {'type': 'number'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Pseudo '
'Offsets'},
'units': {'anyOf': [{'items': {'type': 'string'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Units'}},
'required': ['class',
'multipoles',
'curves',
'powerconverters',
'hardware_units'],
'title': 'LinearCFMagnetModelConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'calibration_factor': {'default': 1.0,
'title': 'Calibration '
'Factor',
'type': 'number'},
'calibration_offset': {'default': 0.0,
'title': 'Calibration '
'Offset',
'type': 'number'},
'class': {'const': 'pyaml.magnet.linear_model.LinearMagnetModel',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'crosstalk': {'default': 1.0,
'title': 'Crosstalk',
'type': 'number'},
'curve': {'anyOf': [{'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.csvcurve.CSVCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'file': {'title': 'File',
'type': 'string'}},
'required': ['class',
'file'],
'title': 'CSVCurveConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.inline_curve.InlineCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'mat': {'items': {'items': {'type': 'number'},
'type': 'array'},
'title': 'Mat',
'type': 'array'}},
'required': ['class',
'mat'],
'title': 'InlineCurveConfigurationSchema',
'type': 'object'}],
'title': 'CurveConfigurationSchema'},
{'type': 'null'}],
'default': None},
'hardware_unit': {'title': 'Hardware '
'Unit',
'type': 'string'},
'powerconverter': {'default': None,
'title': 'Powerconverter',
'type': ['string',
'null']},
'unit': {'title': 'Unit',
'type': 'string'}},
'required': ['class',
'unit',
'hardware_unit'],
'title': 'LinearMagnetModelConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'calibration_factors': {'anyOf': [{'type': 'number'},
{'items': {'type': 'number'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Calibration '
'Factors'},
'calibration_offsets': {'anyOf': [{'type': 'number'},
{'items': {'type': 'number'},
'type': 'array'},
{'type': 'null'}],
'default': None,
'title': 'Calibration '
'Offsets'},
'class': {'const': 'pyaml.magnet.linear_serialized_model.LinearSerializedMagnetModel',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'crosstalk': {'anyOf': [{'type': 'number'},
{'items': {'type': 'number'},
'type': 'array'}],
'default': 1.0,
'title': 'Crosstalk'},
'curves': {'anyOf': [{'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.csvcurve.CSVCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'file': {'title': 'File',
'type': 'string'}},
'required': ['class',
'file'],
'title': 'CSVCurveConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.inline_curve.InlineCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'mat': {'items': {'items': {'type': 'number'},
'type': 'array'},
'title': 'Mat',
'type': 'array'}},
'required': ['class',
'mat'],
'title': 'InlineCurveConfigurationSchema',
'type': 'object'}],
'title': 'CurveConfigurationSchema'},
{'items': {'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.csvcurve.CSVCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'file': {'title': 'File',
'type': 'string'}},
'required': ['class',
'file'],
'title': 'CSVCurveConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.inline_curve.InlineCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'mat': {'items': {'items': {'type': 'number'},
'type': 'array'},
'title': 'Mat',
'type': 'array'}},
'required': ['class',
'mat'],
'title': 'InlineCurveConfigurationSchema',
'type': 'object'}],
'title': 'CurveConfigurationSchema'},
'type': 'array'}],
'title': 'Curves'},
'hardware_unit': {'default': None,
'title': 'Hardware '
'Unit',
'type': ['string',
'null']},
'powerconverter': {'default': None,
'title': 'Powerconverter',
'type': ['string',
'null']},
'unit': {'default': None,
'title': 'Unit',
'type': ['string',
'null']}},
'required': ['class', 'curves'],
'title': 'LinearSerializedMagnetModelConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'alpha': {'default': 0.0,
'title': 'Alpha',
'type': 'number'},
'calibration_factor': {'default': 1.0,
'title': 'Calibration '
'Factor',
'type': 'number'},
'calibration_offset': {'default': 0.0,
'title': 'Calibration '
'Offset',
'type': 'number'},
'class': {'const': 'pyaml.magnet.spline_model.SplineMagnetModel',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'crosstalk': {'default': 1.0,
'title': 'Crosstalk',
'type': 'number'},
'curve': {'anyOf': [{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.csvcurve.CSVCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'file': {'title': 'File',
'type': 'string'}},
'required': ['class',
'file'],
'title': 'CSVCurveConfigurationSchema',
'type': 'object'},
{'additionalProperties': False,
'properties': {'class': {'const': 'pyaml.magnet.inline_curve.InlineCurve',
'description': 'Fully '
'qualified '
'class '
'path.',
'title': 'Class',
'type': 'string'},
'mat': {'items': {'items': {'type': 'number'},
'type': 'array'},
'title': 'Mat',
'type': 'array'}},
'required': ['class',
'mat'],
'title': 'InlineCurveConfigurationSchema',
'type': 'object'}],
'title': 'CurveConfigurationSchema'},
'hardware_unit': {'default': None,
'title': 'Hardware '
'Unit',
'type': ['string',
'null']},
'powerconverter': {'default': None,
'title': 'Powerconverter',
'type': ['string',
'null']},
'unit': {'default': None,
'title': 'Unit',
'type': ['string',
'null']}},
'required': ['class', 'curve'],
'title': 'SplineMagnetModelConfigurationSchema',
'type': 'object'}],
'title': 'MagnetModelConfigurationSchema'},
{'type': 'null'}],
'default': None},
'name': {'title': 'Name', 'type': 'string'}},
'required': ['class', 'name'],
'title': 'QuadrupoleConfigurationSchema',
'type': 'object'}
The result can also be saved directly to a file.
SchemaGenerator.save("pyaml.magnet.quadrupole.Quadrupole","quadrupole-schema.json")
PosixPath('quadrupole-schema.json')