zope.configuration.fields

Configuration-specific schema fields

class zope.configuration.fields.Bool(title=u'', description=u'', __name__='', required=True, readonly=False, constraint=None, default=None, defaultFactory=None, missing_value=<Not Given>)[source]

Bases: zope.schema._bootstrapfields.Bool

A boolean value.

Values may be input (in upper or lower case) as any of:

  • yes / no
  • y / n
  • true / false
  • t / f

Caution

Do not confuse this with zope.schema.Bool. That class will only parse "True" and "true" as True values. Any other value will silently be accepted as False. This class raises a validation error for unrecognized input.

fromUnicode(value)[source]

Convert the input string to a boolean.

Example:

>>> from zope.configuration.fields import Bool
>>> Bool().fromUnicode(u"yes")
True
>>> Bool().fromUnicode(u"y")
True
>>> Bool().fromUnicode(u"true")
True
>>> Bool().fromUnicode(u"no")
False
>>> Bool().fromUnicode(u"surprise")
Traceback (most recent call last):
...
zope.schema._bootstrapinterfaces.InvalidValue
class zope.configuration.fields.GlobalObject(value_type=None, **kw)[source]

Bases: zope.schema._bootstrapfields.Field

An object that can be accessed as a module global.

The special value * indicates a value of None; this is not validated against the value_type.

fromUnicode(value)[source]

Find and return the module global at the path value.

>>> d = {'x': 1, 'y': 42, 'z': 'zope'}
>>> class fakeresolver(dict):
...     def resolve(self, n):
...         return self[n]
>>> fake = fakeresolver(d)
>>> from zope.schema import Int
>>> from zope.configuration.fields import GlobalObject
>>> g = GlobalObject(value_type=Int())
>>> gg = g.bind(fake)
>>> gg.fromUnicode("x")
1
>>> gg.fromUnicode("   x  \n  ")
1
>>> gg.fromUnicode("y")
42
>>> gg.fromUnicode("z")
Traceback (most recent call last):
...
WrongType: ('zope', (<type 'int'>, <type 'long'>), '')
>>> g = GlobalObject(constraint=lambda x: x%2 == 0)
>>> gg = g.bind(fake)
>>> gg.fromUnicode("x")
Traceback (most recent call last):
...
ConstraintNotSatisfied: 1
>>> gg.fromUnicode("y")
42
>>> g = GlobalObject()
>>> gg = g.bind(fake)
>>> print(gg.fromUnicode('*'))
None
class zope.configuration.fields.GlobalInterface(**kw)[source]

Bases: zope.configuration.fields.GlobalObject

An interface that can be accessed from a module.

Example:

First, we need to set up a stub name resolver:

>>> from zope.interface import Interface
>>> class IFoo(Interface):
...     pass
>>> class Foo(object):
...     pass
>>> d = {'Foo': Foo, 'IFoo': IFoo}
>>> class fakeresolver(dict):
...     def resolve(self, n):
...         return self[n]
>>> fake = fakeresolver(d)

Now verify constraints are checked correctly:

>>> from zope.configuration.fields import GlobalInterface
>>> g = GlobalInterface()
>>> gg = g.bind(fake)
>>> gg.fromUnicode('IFoo') is IFoo
True
>>> gg.fromUnicode('  IFoo  ') is IFoo
True
>>> gg.fromUnicode('Foo')
Traceback (most recent call last):
...
NotAnInterface: (<class 'Foo'>, ...
class zope.configuration.fields.MessageID(*args, **kw)[source]

Bases: zope.schema._bootstrapfields.Text

Text string that should be translated.

When a string is converted to a message ID, it is also recorded in the context.

fromUnicode(value)[source]

Translate a string to a MessageID.

>>> from zope.configuration.fields import MessageID
>>> class Info(object):
...     file = 'file location'
...     line = 8
>>> class FauxContext(object):
...     i18n_strings = {}
...     info = Info()
>>> context = FauxContext()
>>> field = MessageID().bind(context)

There is a fallback domain when no domain has been specified.

Exchange the warn function so we can make test whether the warning has been issued

>>> warned = None
>>> def fakewarn(*args, **kw):
...     global warned
...     warned = args
>>> import warnings
>>> realwarn = warnings.warn
>>> warnings.warn = fakewarn
>>> i = field.fromUnicode(u"Hello world!")
>>> i
'Hello world!'
>>> i.domain
'untranslated'
>>> warned
("You did not specify an i18n translation domain for the '' field in file location",)
>>> warnings.warn = realwarn

With the domain specified:

>>> context.i18n_strings = {}
>>> context.i18n_domain = 'testing'

We can get a message id:

>>> i = field.fromUnicode(u"Hello world!")
>>> i
'Hello world!'
>>> i.domain
'testing'

In addition, the string has been registered with the context:

>>> context.i18n_strings
{'testing': {'Hello world!': [('file location', 8)]}}
>>> i = field.fromUnicode(u"Foo Bar")
>>> i = field.fromUnicode(u"Hello world!")
>>> from pprint import PrettyPrinter
>>> pprint=PrettyPrinter(width=70).pprint
>>> pprint(context.i18n_strings)
{'testing': {'Foo Bar': [('file location', 8)],
             'Hello world!': [('file location', 8),
                              ('file location', 8)]}}
>>> from zope.i18nmessageid import Message
>>> isinstance(list(context.i18n_strings['testing'].keys())[0],
...            Message)
True

Explicit Message IDs

>>> i = field.fromUnicode(u'[View-Permission] View')
>>> i
'View-Permission'
>>> i.default
'View'
>>> i = field.fromUnicode(u'[] [Some] text')
>>> i
'[Some] text'
>>> i.default is None
True
class zope.configuration.fields.Path(*args, **kw)[source]

Bases: zope.schema._bootstrapfields.Text

A file path name, which may be input as a relative path

Input paths are converted to absolute paths and normalized.

fromUnicode(value)[source]

Convert the input path to a normalized, absolute path.

Let’s look at an example:

First, we need a “context” for the field that has a path function for converting relative path to an absolute path.

We’ll be careful to do this in an operating system independent fashion.

>>> from zope.configuration.fields import Path
>>> class FauxContext(object):
...    def path(self, p):
...       return os.path.join(os.sep, 'faux', 'context', p)
>>> context = FauxContext()
>>> field = Path().bind(context)

Lets try an absolute path first:

>>> import os
>>> p = os.path.join(os.sep, u'a', u'b')
>>> n = field.fromUnicode(p)
>>> n.split(os.sep)
['', 'a', 'b']

This should also work with extra spaces around the path:

>>> p = "   \n   %s   \n\n   " % p
>>> n = field.fromUnicode(p)
>>> n.split(os.sep)
['', 'a', 'b']

Environment variables are expanded:

>>> os.environ['path-test'] = '42'
>>> with_env = os.path.join(os.sep, u'a', u'${path-test}')
>>> n = field.fromUnicode(with_env)
>>> n.split(os.sep)
['', 'a', '42']

Now try a relative path:

>>> p = os.path.join(u'a', u'b')
>>> n = field.fromUnicode(p)
>>> n.split(os.sep)
['', 'faux', 'context', 'a', 'b']

The current user is expanded (these are implicitly relative paths):

>>> old_home = os.environ.get('HOME')
>>> os.environ['HOME'] = os.path.join(os.sep, 'HOME')
>>> n = field.fromUnicode('~')
>>> n.split(os.sep)
['', 'HOME']
>>> if old_home:
...    os.environ['HOME'] = old_home
... else:
...    del os.environ['HOME']

Changed in version 4.2.0: Start expanding home directories and environment variables.

class zope.configuration.fields.PythonIdentifier(min_length=0, max_length=None, **kw)[source]

Bases: zope.schema._field.PythonIdentifier

This class is like zope.schema.PythonIdentifier.

Let’s look at an example:

>>> from zope.configuration.fields import PythonIdentifier
>>> class FauxContext(object):
...     pass
>>> context = FauxContext()
>>> field = PythonIdentifier().bind(context)

Let’s test the fromUnicode method:

>>> field.fromUnicode(u'foo')
'foo'
>>> field.fromUnicode(u'foo3')
'foo3'
>>> field.fromUnicode(u'_foo3')
'_foo3'

Now let’s see whether validation works alright

>>> values = (u'foo', u'foo3', u'foo_', u'_foo3', u'foo_3', u'foo3_')
>>> for value in values:
...     _ = field.fromUnicode(value)
>>> from zope.schema import ValidationError
>>> for value in (u'3foo', u'foo:', u'\\', u''):
...     try:
...         field.fromUnicode(value)
...     except ValidationError:
...         print('Validation Error ' + repr(value))
Validation Error '3foo'
Validation Error 'foo:'
Validation Error '\\'
Validation Error ''

Changed in version 4.2.0: Extend zope.schema.PythonIdentifier, which implies that fromUnicode validates the strings.

class zope.configuration.fields.Tokens(value_type=<Not Given>, unique=<Not Given>, **kw)[source]

Bases: zope.schema._field.List

A list that can be read from a space-separated string.

fromUnicode(value)[source]

Split the input string and convert it to value_type.

Consider GlobalObject tokens:

First, we need to set up a stub name resolver:

>>> d = {'x': 1, 'y': 42, 'z': 'zope', 'x.y.x': 'foo'}
>>> class fakeresolver(dict):
...     def resolve(self, n):
...         return self[n]
>>> fake = fakeresolver(d)
>>> from zope.configuration.fields import Tokens
>>> from zope.configuration.fields import GlobalObject
>>> g = Tokens(value_type=GlobalObject())
>>> gg = g.bind(fake)
>>> gg.fromUnicode("  \n  x y z  \n")
[1, 42, 'zope']
>>> from zope.schema import Int
>>> g = Tokens(value_type=
...            GlobalObject(value_type=
...                         Int(constraint=lambda x: x%2 == 0)))
>>> gg = g.bind(fake)
>>> gg.fromUnicode("x y")
Traceback (most recent call last):
...
InvalidToken: 1 in x y
>>> gg.fromUnicode("z y")
Traceback (most recent call last):
...
InvalidToken: ('zope', (<type 'int'>, <type 'long'>), '') in z y
>>> gg.fromUnicode("y y")
[42, 42]