zope.i18nmessageid.messageid.MessageID

Package zope :: Package i18nmessageid :: Module messageid :: Class MessageID

[show private | hide private]

Type MessageID

object --+        
         |        
basestring --+    
             |    
       unicode --+
                 |
                MessageID

Message ID.

This is a string used as a message ID. It has a domain attribute that is its source domain, and a default attribute that is its default text to display when there is no translation. domain may be None meaning there is no translation domain. default may also be None, in which case the message id itself implicitly serves as the default text.

MessageID objects also have a mapping attribute which must be set after construction of the object. This is used when translating and substituting variables.

To instanciate MessageIDs, it is recommended to use MessageIDFactory:

>>> fact = MessageIDFactory('test')

Now we can use the factory to make MessageIDs. Note that MessageID is a subclass of unicode:

>>> id = fact(u'this is a test')
>>> isinstance(id, MessageID)
True

>>> isinstance(id, unicode)
True

Additional parameters, such as the i18n domain and the default text are available through attributes:

>>> id.domain
'test'

>>> id.default
u'this is a test'

You can also reset the default text:

>>> id.default = u'blah'
>>> id.default
u'blah'

It is quite common to pass an abstract identifier as message id and then a default text:

>>> id = fact(u'test-id', 'default test')
>>> id
u'test-id'

>>> id.default
u'default test'

>>> id.domain
'test'

Method Summary
	`__getstate__(self)`
	`__new__(cls, ustr, domain, default)` (Static method)
	`__setstate__(self, (ustr, domain, default, mapping))`
Inherited from unicode
	`__add__(x, y)` x.__add__(y) <==> x+y
	`__cmp__(x, y)` x.__cmp__(y) <==> cmp(x,y)
	`__contains__(x, y)` x.__contains__(y) <==> y in x
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__getitem__(x, y)` x.__getitem__(y) <==> x[y]
	`__getnewargs__(...)`
	`__getslice__(x, i, j)` Use of negative indices is not supported.
	`__hash__(x)` x.__hash__() <==> hash(x)
	`__len__(x)` x.__len__() <==> len(x)
	`__mod__(x, y)` x.__mod__(y) <==> x%y
	`__mul__(x, n)` x.__mul__(n) <==> x*n
	`__repr__(x)` x.__repr__() <==> repr(x)
	`__rmod__(x, y)` x.__rmod__(y) <==> y%x
	`__rmul__(x, n)` x.__rmul__(n) <==> n*x
	`__str__(x)` x.__str__() <==> str(x)
	`capitalize(S)` Return a capitalized version of S, i.e.
	`center(S, width, fillchar)` Return S centered in a Unicode string of length width.
	`count(S, sub, start, end)` Return the number of occurrences of substring sub in Unicode string S[start:end].
	`decode(S, encoding, errors)` Decodes S using the codec registered for encoding.
	`encode(S, encoding, errors)` Encodes S using the codec registered for encoding.
	`endswith(S, suffix, start, end)` Return True if S ends with the specified suffix, False otherwise.
	`expandtabs(S, tabsize)` Return a copy of S where all tab characters are expanded using spaces.
	`find(S, sub, start, end)` Return the lowest index in S where substring sub is found, such that sub is contained within s[start,end].
	`index(S, sub, start, end)` Like S.find() but raise ValueError when the substring is not found.
	`isalnum(S)` Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.
	`isalpha(S)` Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise.
	`isdecimal(S)` Return True if there are only decimal characters in S, False otherwise.
	`isdigit(S)` Return True if all characters in S are digits and there is at least one character in S, False otherwise.
	`islower(S)` Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise.
	`isnumeric(S)` Return True if there are only numeric characters in S, False otherwise.
	`isspace(S)` Return True if all characters in S are whitespace and there is at least one character in S, False otherwise.
	`istitle(S)` Return True if S is a titlecased string and there is at least one character in S, i.e.
	`isupper(S)` Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise.
	`join(S, sequence)` Return a string which is the concatenation of the strings in the sequence.
	`ljust(S, width, fillchar)` Return S left justified in a Unicode string of length width.
	`lower(S)` Return a copy of the string S converted to lowercase.
	`lstrip(S, chars)` Return a copy of the string S with leading whitespace removed.
	`replace(...)` S.replace (old, new[, maxsplit]) -> unicode
	`rfind(S, sub, start, end)` Return the highest index in S where substring sub is found, such that sub is contained within s[start,end].
	`rindex(S, sub, start, end)` Like S.rfind() but raise ValueError when the substring is not found.
	`rjust(S, width, fillchar)` Return S right justified in a Unicode string of length width.
	`rsplit(S, sep, maxsplit)` Return a list of the words in S, using sep as the delimiter string, starting at the end of the string and working to the front.
	`rstrip(S, chars)` Return a copy of the string S with trailing whitespace removed.
	`split(S, sep, maxsplit)` Return a list of the words in S, using sep as the delimiter string.
	`splitlines(...)` S.splitlines([keepends]]) -> list of strings
	`startswith(S, prefix, start, end)` Return True if S starts with the specified prefix, False otherwise.
	`strip(S, chars)` Return a copy of the string S with leading and trailing whitespace removed.
	`swapcase(S)` Return a copy of S with uppercase characters converted to lowercase and vice versa.
	`title(S)` Return a titlecased version of S, i.e.
	`translate(S, table)` Return a copy of the string S, where all characters have been mapped through the given translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, Unicode strings or None.
	`upper(S)` Return a copy of S converted to uppercase.
	`zfill(S, width)` Pad a numeric string x with zeros on the left, to fill a field of the specified width.
Inherited from object
	`__init__(...)` x.__init__(...) initializes x; see x.__class__.__doc__ for signature
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__reduce__(...)` helper for pickle
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value

Class Variable Summary
`tuple`	`__slots__` = `('domain', 'default', 'mapping')`
`member_descriptor`	`default` = `<member 'default' of 'MessageID' objects>`
`member_descriptor`	`domain` = `<member 'domain' of 'MessageID' objects>`
`member_descriptor`	`mapping` = `<member 'mapping' of 'MessageID' objects>`

Class Variable Details

slots

Type:: tuple
Value:: ('domain', 'default', 'mapping')

default

Type:: member_descriptor
Value:: <member 'default' of 'MessageID' objects>

domain

Type:: member_descriptor
Value:: <member 'domain' of 'MessageID' objects>

mapping

Type:: member_descriptor
Value:: <member 'mapping' of 'MessageID' objects>

Generated by Epydoc 2.1 on Fri Jun 24 12:01:22 2005

http://epydoc.sf.net

Type MessageID

__slots__

default

domain

mapping

slots