Use the Schema Registry#

This guide shows how to register configuration schemas in the SchemaRegistry and how to explore the contents of the registry. The full functionality is available in the API documentation.

The registry can be used to validate configuration or generate JSON Schemas. More explanation can be found in Configuration Schemas and Validation.

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:

  1. Use the register method

  2. Use the register_schema decorator to automatically register schemas when a module is loaded

    The 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_schema decorator 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 output of the fields in the schema. ConfigurationSchema inherits from Pydantic BaseModel so the functionality of that class is also available. See the Pydantic 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 schemas in the package.

The method automatically scans the pyaml package. For other packages, they need to define entry points in their pyproject.toml for the schemas in those packages to be discovered. For example:

[project.entry-points."pyaml.schemas"]
pyaml_cs_oa = "pyaml_cs_oa"

The entry point supports both defining a whole package or individual modules. For packages the discovery will recursively import schemas in all modules 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(
    '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.control.deviceaccesslist.DeviceAccessList': pyaml.control.deviceaccesslist.DeviceAccessListConfigurationSchema,
    '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,
    'tango.pyaml.attribute.Attribute': tango.pyaml.attribute.AttributeConfigurationSchema,
    'tango.pyaml.attribute_list.AttributeList': tango.pyaml.attribute_list.AttributeListConfigurationSchema,
    'tango.pyaml.attribute_list_read_only.AttributeListReadOnly': tango.pyaml.attribute_list_read_only.AttributeListReadOnlyConfigurationSchema,
    'tango.pyaml.attribute_read_only.AttributeReadOnly': tango.pyaml.attribute_read_only.AttributeReadOnlyConfigurationSchema,
    'tango.pyaml.catalog.Catalog': tango.pyaml.catalog.CatalogConfigurationSchema,
    'tango.pyaml.controlsystem.TangoControlSystem': tango.pyaml.controlsystem.TangoControlSystemConfigurationSchema,
    'tango.pyaml.initializable_element.InitializableElement': tango.pyaml.initializable_element.InitializableElementConfigurationSchema,
    'tango.pyaml.multi_attribute.MultiAttribute': tango.pyaml.multi_attribute.MultiAttributeConfigurationSchema,
    'tango.pyaml.static_catalog.StaticCatalog': tango.pyaml.static_catalog.StaticCatalogConfigurationSchema,
    'tango.pyaml.static_catalog_entry.StaticCatalogEntry': tango.pyaml.static_catalog_entry.StaticCatalogEntryConfigurationSchema,
    'tango.pyaml.tango_catalog.TangoCatalog': tango.pyaml.tango_catalog.TangoCatalogConfigurationSchema,
)

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
- 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
- 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.dynamic_catalog.DynamicCatalog
- pyaml_cs_oa.catalog.Catalog
- 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.controlsystem.OphydAsyncControlSystem
- pyaml_cs_oa.static_catalog_entry.StaticCatalogEntry
- pyaml_cs_oa.static_catalog.StaticCatalog
- tango.pyaml.attribute.Attribute
- tango.pyaml.initializable_element.InitializableElement
- tango.pyaml.attribute_list.AttributeList
- tango.pyaml.attribute_list_read_only.AttributeListReadOnly
- tango.pyaml.attribute_read_only.AttributeReadOnly
- tango.pyaml.multi_attribute.MultiAttribute
- pyaml.control.deviceaccesslist.DeviceAccessList
- tango.pyaml.catalog.Catalog
- tango.pyaml.controlsystem.TangoControlSystem
- tango.pyaml.static_catalog_entry.StaticCatalogEntry
- tango.pyaml.static_catalog.StaticCatalog
- tango.pyaml.tango_catalog.TangoCatalog

 Registered schema classes:
- BPMConfigurationSchema
- ElementConfigurationSchema
- DynamicValidationConfigurationSchema
- MagnetModelConfigurationSchema
- HCorrectorConfigurationSchema
- MagnetConfigurationSchema
- OctupoleConfigurationSchema
- QuadrupoleConfigurationSchema
- SextupoleConfigurationSchema
- SkewOctuConfigurationSchema
- SkewQuadConfigurationSchema
- SkewSextConfigurationSchema
- VCorrectorConfigurationSchema
- CombinedFunctionMagnetConfigurationSchema
- SerializedMagnetsConfigurationSchema
- BetatronTuneMonitorConfigurationSchema
- ABetatronTuneMonitorConfigurationSchema
- RFTransmitterConfigurationSchema
- RFPlantConfigurationSchema
- ChromaticityMonitorConfigurationSchema
- MeasurementToolConfigurationSchema
- ArrayConfigConfigurationSchema
- LinkerConfigModelConfigurationSchema
- 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
- DynamicCatalogConfigurationSchema
- CatalogConfigurationSchema
- EpicsRConfigurationSchema
- EpicsConfigRConfigurationSchema
- EpicsConfigWConfigurationSchema
- EpicsConfigRWConfigurationSchema
- TangoConfigAttConfigurationSchema
- FloatSignalContainerConfigurationSchema
- OASignalConfigurationSchema
- DeviceAccessConfigurationSchema
- EpicsRWConfigurationSchema
- EpicsWConfigurationSchema
- TangoAttConfigurationSchema
- OphydAsyncControlSystemConfigurationSchema
- StaticCatalogEntryConfigurationSchema
- StaticCatalogConfigurationSchema
- AttributeConfigurationSchema
- InitializableElementConfigurationSchema
- AttributeListConfigurationSchema
- AttributeListReadOnlyConfigurationSchema
- AttributeReadOnlyConfigurationSchema
- MultiAttributeConfigurationSchema
- DeviceAccessListConfigurationSchema
- CatalogConfigurationSchema
- TangoControlSystemConfigurationSchema
- StaticCatalogEntryConfigurationSchema
- StaticCatalogConfigurationSchema
- TangoCatalogConfigurationSchema

# Print the number of schemas in the registry
print(f"\nNumber of registered schemas: {len(registry)}")

Number of registered schemas: 86