How to use the heat.engine.constraints.AllowedValues function in heat

update_allowed=True,
            constraints=[constraints.CustomConstraint('keystone.region')]
        ),
        SERVICE: properties.Schema(
            properties.Schema.STRING,
            _('Name or Id of keystone service.'),
            update_allowed=True,
            required=True,
            constraints=[constraints.CustomConstraint('keystone.service')]
        ),
        INTERFACE: properties.Schema(
            properties.Schema.STRING,
            _('Interface type of keystone service endpoint.'),
            update_allowed=True,
            required=True,
            constraints=[constraints.AllowedValues(
                ['public', 'internal', 'admin']
            )]
        ),
        SERVICE_URL: properties.Schema(
            properties.Schema.STRING,
            _('URL of keystone service endpoint.'),
            update_allowed=True,
            required=True
        ),
        ENABLED: properties.Schema(
            properties.Schema.BOOLEAN,
            _('This endpoint is enabled or disabled.'),
            default=True,
            update_allowed=True,
            support_status=support.SupportStatus(version='6.0.0')
        )

support_status = support.SupportStatus(
        support.UNSUPPORTED,
        _('See support.infoblox.com for support.'))

    properties_schema = {
        constants.CONNECTION:
            resource_utils.connection_schema(constants.DDI),
        GROUP_NAME: properties.Schema(
            properties.Schema.STRING,
            _('Name server group name.')),
        MEMBER_ROLE: properties.Schema(
            properties.Schema.STRING,
            _('The role the member plays in the group.'),
            constraints=[
                constraints.AllowedValues(MEMBER_ROLES)
            ]),
        MEMBER_SERVER: properties.Schema(
            properties.Schema.MAP,
            _('A grid member settings in this group.'),
            schema={
                MEMBER_NAME: properties.Schema(
                    properties.Schema.STRING,
                    _('The member name.'),
                    required=True
                ),
                GRID_REPLICATE: properties.Schema(
                    properties.Schema.BOOLEAN,
                    _('Determines if grid replication or zone transfer will '
                      'be used to this server.'),
                    default=True
                ),

'source-nat', 'loadbalancer']),
            ],
            update_allowed=False,
            required=True,
        ),
        IMAGE_NAME: properties.Schema(
            properties.Schema.STRING,
            _('Name of the service VM image'),
            update_allowed=False,
            required=True,
        ),
        SERVICE_SCALING: properties.Schema(
            properties.Schema.STRING,
            _('Indicates whether service scaling is enabled'),
            constraints=[
                constraints.AllowedValues(['True', 'False']),
            ],
            update_allowed=False,
            default='False',
        ),
        SERVICE_INTERFACE_TYPE_LIST: properties.Schema(
            properties.Schema.LIST,
            _('An ordered list of interfaces to be added to this service'),
            required=True,
            constraints=[
                constraints.AllowedValues(['management', 'left',
                                           'right', 'other']),
            ],
            update_allowed=False
        ),
        SHARED_IP_LIST: properties.Schema(
            properties.Schema.LIST,

properties.Schema.STRING
            ),
            required=True),
        ADVERTISE_INTERFACE_VLAN: properties.Schema(
            properties.Schema.STRING,
            _('The VLAN used as the advertising interface '
              'for sending OSPF announcements.')),
        AREA_ID: properties.Schema(
            properties.Schema.STRING,
            _('The area ID value of the OSPF settings.'),
            required=True),
        AREA_TYPE: properties.Schema(
            properties.Schema.STRING,
            _('The OSPF area type.'),
            constraints=[
                constraints.AllowedValues(AREA_TYPES)
            ]),
        AUTHENTICATION_KEY: properties.Schema(
            properties.Schema.STRING,
            _('The authentication password to use for OSPF.')),
        AUTHENTICATION_TYPE: properties.Schema(
            properties.Schema.STRING,
            _('The authentication type used for the OSPF advertisement.'),
            constraints=[
                constraints.AllowedValues(AUTHENTICATION_TYPES)
            ]),
        AUTO_CALC_COST_ENABLED: properties.Schema(
            properties.Schema.BOOLEAN,
            _('Determines if auto calculate cost is enabled or not.'),
            required=True),
        COMMENT: properties.Schema(
            properties.Schema.STRING,

DESCRIPTION: properties.Schema(
            properties.Schema.STRING,
            _('Description of the policy.'),
            update_allowed=True
        ),
        ADMIN_STATE_UP: properties.Schema(
            properties.Schema.BOOLEAN,
            _('The administrative state of the policy.'),
            default=True,
            update_allowed=True
        ),
        ACTION: properties.Schema(
            properties.Schema.STRING,
            _('Action type of the policy.'),
            required=True,
            constraints=[constraints.AllowedValues(L7ACTIONS)],
            update_allowed=True
        ),
        REDIRECT_POOL: properties.Schema(
            properties.Schema.STRING,
            _('ID or name of the pool for REDIRECT_TO_POOL action type.'),
            constraints=[
                constraints.CustomConstraint('neutron.lbaas.pool')
            ],
            update_allowed=True
        ),
        REDIRECT_URL: properties.Schema(
            properties.Schema.STRING,
            _('URL for REDIRECT_TO_URL action type. '
              'This should be a valid URL string.'),
            update_allowed=True
        ),

)

    properties_schema = {
        NAME: properties.Schema(
            properties.Schema.STRING,
            _('Human readable name for the secret.'),
        ),
        PAYLOAD: properties.Schema(
            properties.Schema.STRING,
            _('The unencrypted plain text of the secret.'),
        ),
        SECRET_TYPE: properties.Schema(
            properties.Schema.STRING,
            _('The type of the secret.'),
            constraints=[
                constraints.AllowedValues(_SECRET_TYPES),
            ],
            support_status=support.SupportStatus(version='5.0.0'),
            default=OPAQUE
        ),
        PAYLOAD_CONTENT_TYPE: properties.Schema(
            properties.Schema.STRING,
            _('The type/format the secret data is provided in.'),
            constraints=[
                constraints.AllowedValues([
                    'text/plain',
                    'application/octet-stream',
                ]),
            ],
        ),
        PAYLOAD_CONTENT_ENCODING: properties.Schema(
            properties.Schema.STRING,

constraints=[constraints.Range(min=0)]
        ),
        EXPECTED_CODES: properties.Schema(
            properties.Schema.STRING,
            _('The HTTP status codes expected in response from the '
              'member to declare it healthy. Specify one of the following '
              'values: a single value, such as 200. a list, such as 200, 202. '
              'a range, such as 200-204.'),
            update_allowed=True,
        ),
        HTTP_METHOD: properties.Schema(
            properties.Schema.STRING,
            _('The HTTP method used for requests by the monitor of type '
              'HTTP.'),
            update_allowed=True,
            constraints=[constraints.AllowedValues(HTTP_METHODS)]
        ),
        MAX_RETRIES: properties.Schema(
            properties.Schema.INTEGER,
            _('Number of permissible connection failures before changing the '
              'member status to INACTIVE.'),
            required=True,
            update_allowed=True,
            constraints=[constraints.Range(min=1, max=10)],
        ),
        POOL: properties.Schema(
            properties.Schema.STRING,
            _('ID or name of the load balancing pool.'),
            required=True,
            constraints=[
                constraints.CustomConstraint('octavia.pool')
            ]

'security group rule. The port_range_min attribute constrains '
              'the port_range_max attribute. If the protocol is ICMP, this '
              'value must be an ICMP code.'),
            constraints=[
                constraints.Range(0, 65535)
            ]
        ),
        PROTOCOL: properties.Schema(
            properties.Schema.STRING,
            _('The protocol that is matched by the security group rule. '
              'Allowed values are ah, dccp, egp, esp, gre, icmp, icmpv6, '
              'igmp, ipv6-encap, ipv6-frag, ipv6-icmp, ipv6-nonxt, ipv6-opts, '
              'ipv6-route, ospf, pgm, rsvp, sctp, tcp, udp, udplite, vrrp '
              'and integer representations [0-255].'),
            default='tcp',
            constraints=[constraints.AllowedValues(_allowed_protocols)]
            ),
        REMOTE_GROUP: properties.Schema(
            properties.Schema.STRING,
            _('The remote group name or ID to be associated with this '
              'security group rule.'),
            constraints=[
                constraints.CustomConstraint('neutron.security_group')
            ]
        ),
        REMOTE_IP_PREFIX: properties.Schema(
            properties.Schema.STRING,
            _('The remote IP prefix (CIDR) to be associated with this '
              'security group rule.'),
            constraints=[
                constraints.CustomConstraint('net_cidr')
            ]

for constraint in constraints:
                desc = constraint.get(DESCRIPTION)
                if RANGE in constraint:
                    cdef = constraint.get(RANGE)
                    yield constr.Range(parameters.Schema.get_num(MIN, cdef),
                                       parameters.Schema.get_num(MAX, cdef),
                                       desc)
                if LENGTH in constraint:
                    cdef = constraint.get(LENGTH)
                    yield constr.Length(parameters.Schema.get_num(MIN, cdef),
                                        parameters.Schema.get_num(MAX, cdef),
                                        desc)
                if ALLOWED_VALUES in constraint:
                    cdef = constraint.get(ALLOWED_VALUES)
                    yield constr.AllowedValues(cdef, desc)
                if ALLOWED_PATTERN in constraint:
                    cdef = constraint.get(ALLOWED_PATTERN)
                    yield constr.AllowedPattern(cdef, desc)
                if CUSTOM_CONSTRAINT in constraint:
                    cdef = constraint.get(CUSTOM_CONSTRAINT)
                    yield constr.CustomConstraint(cdef, desc)

update_allowed=True,
            constraints=[constraints.Range(min=1,
                                           max=2147483647)]
        ),
        # designate mandates to the max length of 160 for description
        DESCRIPTION: properties.Schema(
            properties.Schema.STRING,
            _('Description of RecordSet.'),
            update_allowed=True,
            constraints=[constraints.Length(max=160)]
        ),
        TYPE: properties.Schema(
            properties.Schema.STRING,
            _('DNS RecordSet type.'),
            required=True,
            constraints=[constraints.AllowedValues(
                _ALLOWED_TYPES
            )]
        ),
        RECORDS: properties.Schema(
            properties.Schema.LIST,
            _('A list of data for this RecordSet. Each item will be a '
              'separate record in Designate These items should conform to the '
              'DNS spec for the record type - e.g. A records must be IPv4 '
              'addresses, CNAME records must be a hostname. DNS record data '
              'varies based on the type of record. For more details, please '
              'refer rfc 1035.'),
            update_allowed=True,
            required=True
        ),
        ZONE: properties.Schema(
            properties.Schema.STRING,