API

This document describes the low-level API of the interfaces and classes provided by this package. The narrative documentation is a better guide to the intended usage.

Interfaces

interface zope.schema.interfaces.IField

Extends: zope.schema._bootstrapinterfaces.IValidatable

Basic Schema Field Interface.

Fields are used for Interface specifications. They at least provide a title, description and a default value. You can also specify if they are required and/or readonly.

The Field Interface is also used for validation and specifying constraints.

We want to make it possible for a IField to not only work on its value but also on the object this value is bound to. This enables a Field implementation to perform validation against an object which also marks a certain place.

Note that many fields need information about the object containing a field. For example, when validating a value to be set as an object attribute, it may be necessary for the field to introspect the object’s state. This means that the field needs to have access to the object when performing validation:

bound = field.bind(object)
bound.validate(value)

interface zope.schema.interfaces.IChoice

Extends: zope.schema.interfaces.IField

Field whose value is contained in a predefined set

Only one, values or vocabulary, may be specified for a given choice.

interface zope.schema.interfaces.IContextAwareDefaultFactory

A default factory that requires a context.

The context is the field context. If the field is not bound, context may be None.

interface zope.schema.interfaces.IOrderable

Extends: zope.schema.interfaces.IField

Field requiring its value to be orderable.

The set of value needs support a complete ordering; the implementation mechanism is not constrained. Either __cmp__() or ‘rich comparison’ methods may be used.

interface zope.schema.interfaces.ILen

Extends: zope.schema.interfaces.IField

A Field requiring its value to have a length.

The value needs to have a conventional __len__ method.

interface zope.schema.interfaces.IMinMax

Extends: zope.schema.interfaces.IOrderable

Field requiring its value to be between min and max.

This implies that the value needs to support the IOrderable interface.

interface zope.schema.interfaces.IMinMaxLen

Extends: zope.schema.interfaces.ILen

Field requiring the length of its value to be within a range

interface zope.schema.interfaces.IInterfaceField

Extends: zope.schema.interfaces.IField

Fields with a value that is an interface (implementing zope.interface.Interface).

interface zope.schema.interfaces.IBool

Extends: zope.schema.interfaces.IField

Boolean Field.

interface zope.schema.interfaces.IObject

Extends: zope.schema.interfaces.IField

Field containing an Object value.

Changed in version 4.6.0: Add the validate_invariants attribute.

Conversions

interface zope.schema.interfaces.IFromBytes

Parse a byte string to a value.

If the string needs to be decoded, decoding is done using UTF-8.

Added in version 4.8.0.

interface zope.schema.interfaces.IFromUnicode

Parse a unicode string to a value

We will often adapt fields to this interface to support views and other applications that need to convert raw data as unicode values.

Strings

interface zope.schema.interfaces.IBytes

Extends: zope.schema.interfaces.IMinMaxLen, zope.schema.interfaces.IIterable, zope.schema.interfaces.IField

Field containing a byte string (like the python str).

The value might be constrained to be with length limits.

interface zope.schema.interfaces.IBytesLine

Extends: zope.schema.interfaces.IBytes

Field containing a byte string without newlines.

interface zope.schema.interfaces.IText

Extends: zope.schema.interfaces.IMinMaxLen, zope.schema.interfaces.IIterable, zope.schema.interfaces.IField

Field containing a unicode string.

interface zope.schema.interfaces.ITextLine

Extends: zope.schema.interfaces.IText

Field containing a unicode string without newlines.

interface zope.schema.interfaces.IASCII

Extends: zope.schema.interfaces.INativeString

Field containing a 7-bit ASCII string. No characters > DEL (chr(127)) are allowed

The value might be constrained to be with length limits.

interface zope.schema.interfaces.IASCIILine

Extends: zope.schema.interfaces.IASCII

Field containing a 7-bit ASCII string without newlines.

interface zope.schema.interfaces.INativeString

Extends: zope.schema.interfaces.IText

A field that always contains the native str type.

Changed in version 4.9.0: This is now a distinct type instead of an alias for either IText or IBytes, depending on the platform.

interface zope.schema.interfaces.INativeStringLine

Extends: zope.schema.interfaces.ITextLine

A field that always contains the native str type, without any newlines.

Changed in version 4.9.0: This is now a distinct type instead of an alias for either ITextLine or IBytesLine, depending on the platform.

interface zope.schema.interfaces.IPassword

Extends: zope.schema.interfaces.ITextLine

Field containing a unicode password string without newlines.

interface zope.schema.interfaces.IURI

Extends: zope.schema.interfaces.INativeStringLine

A field containing an absolute URI

interface zope.schema.interfaces.IId

Extends: zope.schema.interfaces.INativeStringLine

A field containing a unique identifier

A unique identifier is either an absolute URI or a dotted name. If it’s a dotted name, it should have a module/package name as a prefix.

interface zope.schema.interfaces.IPythonIdentifier

Extends: zope.schema.interfaces.INativeStringLine

A single Python identifier, such as a variable name.

Added in version 4.9.0.

interface zope.schema.interfaces.IDottedName

Extends: zope.schema.interfaces.INativeStringLine

Dotted name field.

Values of DottedName fields must be Python-style dotted names.

Numbers

interface zope.schema.interfaces.INumber

Extends: zope.schema.interfaces.IMinMax, zope.schema.interfaces.IField

Field containing a generic number: numbers.Number.

See also

zope.schema.Number

Added in version 4.6.0.

interface zope.schema.interfaces.IComplex

Extends: zope.schema.interfaces.INumber

Field containing a complex number: numbers.Complex.

See also

zope.schema.Real

Added in version 4.6.0.

interface zope.schema.interfaces.IReal

Extends: zope.schema.interfaces.IComplex

Field containing a real number: numbers.IReal.

See also

zope.schema.Real

Added in version 4.6.0.

interface zope.schema.interfaces.IRational

Extends: zope.schema.interfaces.IReal

Field containing a rational number: numbers.IRational.

See also

zope.schema.Rational

Added in version 4.6.0.

interface zope.schema.interfaces.IIntegral

Extends: zope.schema.interfaces.IRational

Field containing an integral number: class:numbers.Integral.

See also

zope.schema.Integral

Added in version 4.6.0.

interface zope.schema.interfaces.IInt

Extends: zope.schema.interfaces.IIntegral

Field containing exactly the native class int.

See also

zope.schema.Int

interface zope.schema.interfaces.IFloat

Extends: zope.schema.interfaces.IReal

Field containing exactly the native class float.

IReal is a more general interface, allowing all of floats, ints, and fractions.

See also

zope.schema.Float

interface zope.schema.interfaces.IDecimal

Extends: zope.schema.interfaces.INumber

Field containing a decimal.Decimal

Date/Time

interface zope.schema.interfaces.IDatetime

Extends: zope.schema.interfaces.IMinMax, zope.schema.interfaces.IField

Field containing a datetime.

interface zope.schema.interfaces.IDate

Extends: zope.schema.interfaces.IMinMax, zope.schema.interfaces.IField

Field containing a date.

interface zope.schema.interfaces.ITimedelta

Extends: zope.schema.interfaces.IMinMax, zope.schema.interfaces.IField

Field containing a timedelta.

interface zope.schema.interfaces.ITime

Extends: zope.schema.interfaces.IMinMax, zope.schema.interfaces.IField

Field containing a time.

Collections

interface zope.schema.interfaces.IIterable

Extends: zope.schema.interfaces.IField

Fields with a value that can be iterated over.

The value needs to support iteration; the implementation mechanism is not constrained. (Either __iter__() or __getitem__() may be used.)

interface zope.schema.interfaces.IContainer

Extends: zope.schema.interfaces.IField

Fields whose value allows an x in value check.

The value needs to support the in operator, but is not constrained in how it does so (whether it defines __contains__() or __getitem__() is immaterial).

interface zope.schema.interfaces.ICollection

Extends: zope.schema.interfaces.IMinMaxLen, zope.schema.interfaces.IIterable, zope.schema.interfaces.IContainer

Abstract interface containing a collection value.

The Value must be iterable and may have a min_length/max_length.

interface zope.schema.interfaces.ISequence

Extends: zope.schema.interfaces.ICollection

Abstract interface specifying that the value is ordered

interface zope.schema.interfaces.IMutableSequence

Extends: zope.schema.interfaces.ISequence

Abstract interface specifying that the value is ordered and mutable.

Added in version 4.6.0.

interface zope.schema.interfaces.IUnorderedCollection

Extends: zope.schema.interfaces.ICollection

Abstract interface specifying that the value cannot be ordered

interface zope.schema.interfaces.IAbstractSet

Extends: zope.schema.interfaces.IUnorderedCollection

An unordered collection of unique values.

interface zope.schema.interfaces.IAbstractBag

Extends: zope.schema.interfaces.IUnorderedCollection

An unordered collection of values, with no limitations on whether members are unique

interface zope.schema.interfaces.ITuple

Extends: zope.schema.interfaces.ISequence

Field containing a value that implements the API of a conventional Python tuple.

interface zope.schema.interfaces.IList

Extends: zope.schema.interfaces.IMutableSequence

Field containing a value that implements the API of a conventional Python list.

interface zope.schema.interfaces.ISet

Extends: zope.schema.interfaces.IAbstractSet

Field containing a value that implements the API of a Python2.4+ set.

interface zope.schema.interfaces.IFrozenSet

Extends: zope.schema.interfaces.IAbstractSet

Field containing a value that implements the API of a conventional Python 2.4+ frozenset.

Mappings

interface zope.schema.interfaces.IMapping

Extends: zope.schema.interfaces.IMinMaxLen, zope.schema.interfaces.IIterable, zope.schema.interfaces.IContainer

Field containing an instance of collections.Mapping.

The key_type and value_type fields allow specification of restrictions for keys and values contained in the dict.

interface zope.schema.interfaces.IMutableMapping

Extends: zope.schema.interfaces.IMapping

Field containing an instance of collections.MutableMapping.

interface zope.schema.interfaces.IDict

Extends: zope.schema.interfaces.IMutableMapping

Field containing a conventional dict.

Events

interface zope.schema.interfaces.IBeforeObjectAssignedEvent

An object is going to be assigned to an attribute on another object.

Subscribers to this event can change the object on this event to change what object is going to be assigned. This is useful, e.g. for wrapping or replacing objects before they get assigned to conform to application policy.

interface zope.schema.interfaces.IFieldEvent

interface zope.schema.interfaces.IFieldUpdatedEvent

Extends: zope.schema.interfaces.IFieldEvent

A field has been modified

Subscribers will get the old and the new value together with the field

Vocabularies

interface zope.schema.interfaces.ITerm

Object representing a single value in a vocabulary.

interface zope.schema.interfaces.ITokenizedTerm

Extends: zope.schema.interfaces.ITerm

Object representing a single value in a tokenized vocabulary.

interface zope.schema.interfaces.ITitledTokenizedTerm

Extends: zope.schema.interfaces.ITokenizedTerm

A tokenized term that includes a title.

interface zope.schema.interfaces.ISource

A set of values from which to choose

Sources represent sets of values. They are used to specify the source for choice fields.

Sources can be large (even infinite), in which case, they need to be queried to find out what their values are.

interface zope.schema.interfaces.ISourceQueriables

A collection of objects for querying sources

interface zope.schema.interfaces.IContextSourceBinder

interface zope.schema.interfaces.IBaseVocabulary

Extends: zope.schema.interfaces.ISource

Representation of a vocabulary.

At this most basic level, a vocabulary only need to support a test for containment. This can be implemented either by __contains__() or by sequence __getitem__() (the later only being useful for vocabularies which are intrinsically ordered).

interface zope.schema.interfaces.IIterableVocabulary

Vocabulary which supports iteration over allowed values.

The objects iteration provides must conform to the ITerm interface.

interface zope.schema.interfaces.IIterableSource

Extends: zope.schema.interfaces.ISource

Source which supports iteration over allowed values.

The objects iteration provides must be values from the source.

interface zope.schema.interfaces.IVocabulary

Extends: zope.schema.interfaces.IIterableVocabulary, zope.schema.interfaces.IBaseVocabulary

Vocabulary which is iterable.

interface zope.schema.interfaces.IVocabularyTokenized

Extends: zope.schema.interfaces.IVocabulary

Vocabulary that provides support for tokenized representation.

Terms returned from getTerm() and provided by iteration must conform to ITokenizedTerm.

interface zope.schema.interfaces.ITreeVocabulary

Extends: zope.schema.interfaces.IVocabularyTokenized, zope.interface.common.mapping.IEnumerableMapping

A tokenized vocabulary with a tree-like structure.

The tree is implemented as dictionary, with keys being ITokenizedTerm terms and the values being similar dictionaries. Leaf values are empty dictionaries.

interface zope.schema.interfaces.IVocabularyRegistry

Registry that provides IBaseVocabulary objects for specific fields.

The fields of this package use the vocabulary registry that is returned from getVocabularyRegistry(). This is a hook function; by default it returns an instance of VocabularyRegistry, but the function setVocabularyRegistry() can be used to change this.

In particular, the package zope.vocabularyregistry can be used to install a vocabulary registry that uses the zope.component architecture.

interface zope.schema.interfaces.IVocabularyFactory

An object that can create IBaseVocabulary.

Objects that implement this interface can be registered with the default VocabularyRegistry provided by this package.

Alternatively, zope.vocabularyregistry can be used to install a IVocabularyRegistry that looks for named utilities using zope.component.getUtility() which provide this interface.

Exceptions

exception zope.schema._bootstrapinterfaces.ValidationError

Raised if the Validation process fails.

exception zope.schema.ValidationError

The preferred alias for zope.schema._bootstrapinterfaces.ValidationError.

exception zope.schema.interfaces.StopValidation

Raised if the validation is completed early.

Note that this exception should be always caught, since it is just a way for the validator to save time.

exception zope.schema.interfaces.RequiredMissing

Required input is missing.

exception zope.schema.interfaces.WrongType(value, expected_type, name)

Object is of wrong type.

Changed in version 4.7.0: Added named arguments to the constructor and the expected_type field.

exception zope.schema.interfaces.ConstraintNotSatisfied

Constraint not satisfied

exception zope.schema.interfaces.NotAContainer

Not a container

exception zope.schema.interfaces.NotAnIterator

Not an iterator

exception zope.schema.interfaces.NotAnInterface(value, expected_type, name)

Object is not an interface.

This is a WrongType exception for backwards compatibility with existing except clauses, but it is raised when IInterface.providedBy is not true, so it’s also a SchemaNotProvided. The expected_type field is filled in as IInterface; this is not actually a type, and isinstance(thing, IInterface) is always false.

Added in version 4.7.0.

Changed in version 4.7.0: Added named arguments to the constructor and the expected_type field.

Bounds

exception zope.schema.interfaces.OutOfBounds(value, bound)

A value was out of the allowed bounds.

This is the common superclass for OrderableOutOfBounds and LenOutOfBounds, which in turn are the superclasses for TooBig and TooSmall, and TooLong and TooShort, respectively.

Added in version 4.7.0.

exception zope.schema.interfaces.OrderableOutOfBounds(value, bound)

A value was too big or too small in comparison to another value.

Added in version 4.7.0.

exception zope.schema.interfaces.LenOutOfBounds(value, bound)

The length of the value was out of bounds.

Added in version 4.7.0.

exception zope.schema.interfaces.TooSmall(value, bound)

Value is too small

exception zope.schema.interfaces.TooBig(value, bound)

Value is too big

exception zope.schema.interfaces.TooLong(value, bound)

Value is too long

exception zope.schema.interfaces.TooShort(value, bound)

Value is too short

exception zope.schema.interfaces.InvalidValue

Invalid value

exception zope.schema.interfaces.WrongContainedType(errors, name)

Wrong contained type

Changed in version 4.7.0: Added named arguments to the constructor, and the errors property.

exception zope.schema.interfaces.NotUnique

One or more entries of sequence are not unique.

exception zope.schema.interfaces.SchemaNotFullyImplemented

Schema not fully implemented

exception zope.schema.interfaces.SchemaNotProvided(schema, value)

Schema not provided

Changed in version 4.7.0: Added named arguments to the constructor and the schema property.

exception zope.schema.interfaces.InvalidURI

The specified URI is not valid.

exception zope.schema.interfaces.InvalidId

The specified id is not valid.

exception zope.schema.interfaces.InvalidDottedName

The specified dotted name is not valid.

exception zope.schema.interfaces.Unbound

The field is not bound.

Schema APIs

zope.schema.getFields(schema)

Return a dictionary containing all the Fields in a schema.

zope.schema.getFieldsInOrder(schema, _field_key=<function <lambda>>)

Return a list of (name, value) tuples in native schema order.

zope.schema.getFieldNames(schema)

Return a list of all the Field names in a schema.

zope.schema.getFieldNamesInOrder(schema)

Return a list of all the Field names in a schema in schema order.

zope.schema.getValidationErrors(schema, value)

Validate that value conforms to the schema interface schema.

This includes checking for any schema validation errors (using getSchemaValidationErrors). If that succeeds, then we proceed to check for any declared invariants.

Note that this does not include a check to see if the value actually provides the given schema.

Returns:

A sequence of (name, zope.interface.Invalid) tuples, where name is None if the error was from an invariant. If the sequence is empty, there were no errors.

zope.schema.getSchemaValidationErrors(schema, value)

Validate that value conforms to the schema interface schema.

All zope.schema.interfaces.IField members of the schema are validated after being bound to value. (Note that we do not check for arbitrary zope.interface.Attribute members being present.)

Returns:

A sequence of (name, ValidationError) tuples. A non-empty sequence indicates validation failed.

Field Implementations

class zope.schema.Field(title='', description='', __name__='', required=True, readonly=False, constraint=None, default=None, defaultFactory=None, missing_value=<Not Given>)

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Collection(value_type=<Not Given>, unique=<Not Given>, **kw)

A generic collection implementing zope.schema.interfaces.ICollection.

Subclasses can define the attribute value_type to be a field such as an Object that will be checked for each member of the collection. This can then be omitted from the constructor call.

They can also define the attribute _type to be a concrete class (or tuple of classes) that the collection itself will be checked to be an instance of. This cannot be set in the constructor.

Changed in version 4.6.0: Add the ability for subclasses to specify value_type and unique, and allow eliding them from the constructor.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

zope.schema._field.AbstractCollection

An alternate name for Collection.

Deprecated since version 4.6.0: Use Collection instead.

class zope.schema.Bool(title='', description='', __name__='', required=True, readonly=False, constraint=None, default=None, defaultFactory=None, missing_value=<Not Given>)

A field representing a Bool.

Changed in version 4.8.0: Implement zope.schema.interfaces.IFromBytes

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Choice(values=None, vocabulary=None, source=None, **kw)

Choice fields can have a value found in a constant or dynamic set of values given by the field definition.

Initialize object.

class zope.schema.Container(title='', description='', __name__='', required=True, readonly=False, constraint=None, default=None, defaultFactory=None, missing_value=<Not Given>)

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Date(min=None, max=None, default=None, **kw)

Field containing a date.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Datetime(*args, **kw)

Field containing a datetime.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Dict(key_type=None, value_type=None, **kw)

A field representing a Dict.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.FrozenSet(*args, **kwargs)

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Id(*args, **kw)

Id field

Values of id fields must be either uris or dotted names.

Changed in version 4.8.0: Implement zope.schema.interfaces.IFromBytes

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.InterfaceField(title='', description='', __name__='', required=True, readonly=False, constraint=None, default=None, defaultFactory=None, missing_value=<Not Given>)

Fields with a value that is an interface (implementing zope.interface.Interface).

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Iterable(title='', description='', __name__='', required=True, readonly=False, constraint=None, default=None, defaultFactory=None, missing_value=<Not Given>)

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.List(value_type=<Not Given>, unique=<Not Given>, **kw)

A field representing a List.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Mapping(key_type=None, value_type=None, **kw)

A field representing a mapping.

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.MutableMapping(key_type=None, value_type=None, **kw)

A field representing a mutable mapping.

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.MutableSequence(value_type=<Not Given>, unique=<Not Given>, **kw)

A field representing a mutable sequence.

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.MinMaxLen(min_length=0, max_length=None, **kw)

Expresses constraints on the length of a field.

MinMaxLen is a mixin used in combination with Field.

class zope.schema.Object(schema=<Not Given>, *, validate_invariants=True, **kwargs)

Implementation of zope.schema.interfaces.IObject.

Create an IObject field. The keyword arguments are as for Field.

Changed in version 4.6.0: Add the keyword argument validate_invariants. When true (the default), the schema’s validateInvariants method will be invoked to check the @invariant properties of the schema.

Changed in version 4.6.0: The schema argument can be ommitted in a subclass that specifies a schema attribute.

class zope.schema.Orderable(min=None, max=None, default=None, **kw)

Values of ordered fields can be sorted.

They can be restricted to a range of values.

Orderable is a mixin used in combination with Field.

class zope.schema.Set(*args, **kwargs)

A field representing a set.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Sequence(value_type=<Not Given>, unique=<Not Given>, **kw)

A field representing an ordered sequence.

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Time(min=None, max=None, default=None, **kw)

Field containing a time.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Timedelta(min=None, max=None, default=None, **kw)

Field containing a timedelta.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Tuple(value_type=<Not Given>, unique=<Not Given>, **kw)

A field representing a Tuple.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.URI(*args, **kw)

URI schema field.

URIs can be validated from both unicode values and bytes values, producing a native text string in both cases:

>>> from zope.schema import URI
>>> field = URI()
>>> field.fromUnicode(u'   https://example.com  ')
'https://example.com'
>>> field.fromBytes(b'   https://example.com ')
'https://example.com'

Changed in version 4.8.0: Implement zope.schema.interfaces.IFromBytes

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

Strings

class zope.schema.ASCII(*args, **kw)

Field containing a 7-bit ASCII string. No characters > DEL (chr(127)) are allowed

The value might be constrained to be with length limits.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.ASCIILine(*args, **kw)

Field containing a 7-bit ASCII string without newlines.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Bytes(min_length=0, max_length=None, **kw)

Field containing a byte string (like the python str).

The value might be constrained to be with length limits.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.BytesLine(min_length=0, max_length=None, **kw)

A Bytes field with no newlines.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.SourceText(*args, **kw)

Field for source text of object.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Text(*args, **kw)

A field containing text used for human discourse.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.TextLine(*args, **kw)

A text field with no newlines.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.NativeString(*args, **kw)

A native string is always the type str.

In addition to INativeString, this implements IFromUnicode and IFromBytes.

Changed in version 4.9.0: This is now a distinct type instead of an alias for either Text or Bytes, depending on the platform.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.NativeStringLine(*args, **kw)

A native string is always the type str; this field excludes newlines.

In addition to INativeStringLine, this implements IFromUnicode and IFromBytes.

Changed in version 4.9.0: This is now a distinct type instead of an alias for either TextLine or BytesLine, depending on the platform.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Password(*args, **kw)

A text field containing a text used as a password.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.DottedName(*args, **kw)

Dotted name field.

Values of DottedName fields must be Python-style dotted names.

Dotted names can be validated from both unicode values and bytes values, producing a native text string in both cases:

>>> from zope.schema import DottedName
>>> field = DottedName()
>>> field.fromUnicode(u'zope.schema')
'zope.schema'
>>> field.fromBytes(b'zope.schema')
'zope.schema'
>>> field.fromUnicode(u'zope._schema')
'zope._schema'

Changed in version 4.8.0: Implement zope.schema.interfaces.IFromBytes

Changed in version 4.9.0: Allow leading underscores in each component.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.PythonIdentifier(*args, **kw)

This field describes a python identifier, i.e. a variable name.

Empty strings are allowed.

Identifiers can be validated from both unicode values and bytes values, producing a native text string in both cases:

>>> from zope.schema import PythonIdentifier
>>> field = PythonIdentifier()
>>> field.fromUnicode(u'zope')
'zope'
>>> field.fromBytes(b'_zope')
'_zope'
>>> field.fromUnicode(u'   ')
''

Added in version 4.9.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

Numbers

class zope.schema.Number(min=None, max=None, default=None, **kw)

A field representing a numbers.Number and implementing zope.schema.interfaces.INumber.

The fromUnicode() method will attempt to use the smallest or strictest possible type to represent incoming strings:

>>> from zope.schema._bootstrapfields import Number
>>> f = Number()
>>> f.fromUnicode(u"1")
1
>>> f.fromUnicode(u"125.6")
125.6
>>> f.fromUnicode(u"1+0j")
(1+0j)
>>> f.fromUnicode(u"1/2")
Fraction(1, 2)
>>> f.fromUnicode(str(2**11234) + '.' + str(2**256))
...
Decimal('590...936')
>>> f.fromUnicode(u"not a number")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Decimal: 'not a number'

Similarly, fromBytes() will do the same for incoming byte strings:

>>> from zope.schema._bootstrapfields import Number
>>> f = Number()
>>> f.fromBytes(b"1")
1
>>> f.fromBytes(b"125.6")
125.6
>>> f.fromBytes(b"1+0j")
(1+0j)
>>> f.fromBytes(b"1/2")
Fraction(1, 2)
>>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode('ascii'))
...
Decimal('590...936')
>>> f.fromBytes(b"not a number")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Decimal: 'not a number'

Added in version 4.6.0.

Changed in version 4.8.0: Implement zope.schema.interfaces.IFromBytes

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Complex(min=None, max=None, default=None, **kw)

A field representing a numbers.Complex and implementing zope.schema.interfaces.IComplex.

The fromUnicode() method is like that for Number, but doesn’t allow Decimals:

>>> from zope.schema._bootstrapfields import Complex
>>> f = Complex()
>>> f.fromUnicode(u"1")
1
>>> f.fromUnicode(u"125.6")
125.6
>>> f.fromUnicode(u"1+0j")
(1+0j)
>>> f.fromUnicode(u"1/2")
Fraction(1, 2)
>>> f.fromUnicode(str(2**11234) + '.' + str(2**256))
...
inf
>>> f.fromUnicode(u"not a number")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Decimal: 'not a number'

Similarly for fromBytes():

>>> from zope.schema._bootstrapfields import Complex
>>> f = Complex()
>>> f.fromBytes(b"1")
1
>>> f.fromBytes(b"125.6")
125.6
>>> f.fromBytes(b"1+0j")
(1+0j)
>>> f.fromBytes(b"1/2")
Fraction(1, 2)
>>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode('ascii'))
...
inf
>>> f.fromBytes(b"not a number")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Decimal: 'not a number'

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Real(min=None, max=None, default=None, **kw)

A field representing a numbers.Real and implementing zope.schema.interfaces.IReal.

The fromUnicode() method is like that for Complex, but doesn’t allow Decimals or complex numbers:

>>> from zope.schema._bootstrapfields import Real
>>> f = Real()
>>> f.fromUnicode("1")
1
>>> f.fromUnicode("125.6")
125.6
>>> f.fromUnicode("1+0j")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Fraction: '1+0j'
>>> f.fromUnicode("1/2")
Fraction(1, 2)
>>> f.fromUnicode(str(2**11234) + '.' + str(2**256))
...
inf
>>> f.fromUnicode("not a number")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Decimal: 'not a number'

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Rational(min=None, max=None, default=None, **kw)

A field representing a numbers.Rational and implementing zope.schema.interfaces.IRational.

The fromUnicode() method is like that for Real, but does not allow arbitrary floating point numbers:

>>> from zope.schema._bootstrapfields import Rational
>>> f = Rational()
>>> f.fromUnicode("1")
1
>>> f.fromUnicode("1/2")
Fraction(1, 2)
>>> f.fromUnicode("125.6")
Fraction(628, 5)
>>> f.fromUnicode("1+0j")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Fraction: '1+0j'
>>> f.fromUnicode(str(2**11234) + '.' + str(2**256))
...
Fraction(195..., 330...)
>>> f.fromUnicode("not a number")
Traceback (most recent call last):
...
InvalidNumberLiteral: Invalid literal for Decimal: 'not a number'

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Integral(min=None, max=None, default=None, **kw)

A field representing a numbers.Integral and implementing zope.schema.interfaces.IIntegral.

The fromUnicode() method only allows integral values:

>>> from zope.schema._bootstrapfields import Integral
>>> f = Integral()
>>> f.fromUnicode("125")
125
>>> f.fromUnicode("125.6")
Traceback (most recent call last):
...
InvalidIntLiteral: invalid literal for int(): 125.6

Similarly for fromBytes():

>>> from zope.schema._bootstrapfields import Integral
>>> f = Integral()
>>> f.fromBytes(b"125")
125
>>> f.fromBytes(b"125.6")
Traceback (most recent call last):
...
InvalidIntLiteral: invalid literal for int(): 125.6

Added in version 4.6.0.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Float(min=None, max=None, default=None, **kw)

A field representing a native float and implementing zope.schema.interfaces.IFloat.

The class zope.schema.Real is a more general version, accepting floats, integers, and fractions.

The fromUnicode() method only accepts values that can be parsed by the float constructor:

>>> from zope.schema._field import Float
>>> f = Float()
>>> f.fromUnicode("1")
1.0
>>> f.fromUnicode("125.6")
125.6
>>> f.fromUnicode("1+0j")
Traceback (most recent call last):
...
InvalidFloatLiteral: Invalid literal for float(): 1+0j
>>> f.fromUnicode("1/2")
Traceback (most recent call last):
...
InvalidFloatLiteral: invalid literal for float(): 1/2
>>> f.fromUnicode(str(2**11234) + '.' + str(2**256))
...
inf
>>> f.fromUnicode("not a number")
Traceback (most recent call last):
...
InvalidFloatLiteral: could not convert string to float: not a number

Likewise for fromBytes():

>>> from zope.schema._field import Float
>>> f = Float()
>>> f.fromBytes(b"1")
1.0
>>> f.fromBytes(b"125.6")
125.6
>>> f.fromBytes(b"1+0j")
Traceback (most recent call last):
...
InvalidFloatLiteral: Invalid literal for float(): 1+0j
>>> f.fromBytes(b"1/2")
Traceback (most recent call last):
...
InvalidFloatLiteral: invalid literal for float(): 1/2
>>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode('ascii'))
...
inf
>>> f.fromBytes(b"not a number")
Traceback (most recent call last):
...
InvalidFloatLiteral: could not convert string to float: not a number

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Int(min=None, max=None, default=None, **kw)

A field representing a native integer type. and implementing zope.schema.interfaces.IInt.

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

class zope.schema.Decimal(min=None, max=None, default=None, **kw)

A field representing a native decimal.Decimal and implementing zope.schema.interfaces.IDecimal.

The fromUnicode() method only accepts values that can be parsed by the Decimal constructor:

>>> from zope.schema._field import Decimal
>>> f = Decimal()
>>> f.fromUnicode("1")
Decimal('1')
>>> f.fromUnicode("125.6")
Decimal('125.6')
>>> f.fromUnicode("1+0j")
Traceback (most recent call last):
...
InvalidDecimalLiteral: Invalid literal for Decimal(): 1+0j
>>> f.fromUnicode("1/2")
Traceback (most recent call last):
...
InvalidDecimalLiteral: Invalid literal for Decimal(): 1/2
>>> f.fromUnicode(str(2**11234) + '.' + str(2**256))
...
Decimal('5901...936')
>>> f.fromUnicode("not a number")
Traceback (most recent call last):
...
InvalidDecimalLiteral: could not convert string to float: not a number

Likewise for fromBytes():

>>> from zope.schema._field import Decimal
>>> f = Decimal()
>>> f.fromBytes(b"1")
Decimal('1')
>>> f.fromBytes(b"125.6")
Decimal('125.6')
>>> f.fromBytes(b"1+0j")
Traceback (most recent call last):
...
InvalidDecimalLiteral: Invalid literal for Decimal(): 1+0j
>>> f.fromBytes(b"1/2")
Traceback (most recent call last):
...
InvalidDecimalLiteral: Invalid literal for Decimal(): 1/2
>>> f.fromBytes((str(2**11234) + '.' + str(2**256)).encode("ascii"))
...
Decimal('5901...936')
>>> f.fromBytes(b"not a number")
Traceback (most recent call last):
...
InvalidDecimalLiteral: could not convert string to float: not a number

Pass in field values as keyword parameters.

Generally, you want to pass either a title and description, or a doc string. If you pass no doc string, it will be computed from the title and description. If you pass a doc string that follows the Python coding style (title line separated from the body by a blank line), the title and description will be computed from the doc string. Unfortunately, the doc string must be passed as a positional argument.

Here are some examples:

>>> from zope.schema._bootstrapfields import Field
>>> f = Field()
>>> f.__doc__, str(f.title), str(f.description)
('', '', '')

>>> f = Field(title=u'sample')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample', 'sample', '')

>>> f = Field(title=u'sample', description=u'blah blah\nblah')
>>> str(f.__doc__), str(f.title), str(f.description)
('sample\n\nblah blah\nblah', 'sample', 'blah blah\nblah')

Vocabularies

Vocabulary support for schema.

Accessors

Field accessors

Accessors are used to model methods used to access data defined by fields. Accessors are fields that work by decorating existing fields.

To define accessors in an interface, use the accessors function:

class IMyInterface(Interface):

   getFoo, setFoo = accessors(Text(title=u'Foo', ...))

   getBar = accessors(TextLine(title=u'Foo', readonly=True, ...)

Normally a read accessor and a write accessor are defined. Only a read accessor is defined for read-only fields.

Read accessors function as access method specifications and as field specifications. Write accessors are solely method specifications.

zope.schema.accessors.accessors(field)