DTML utility functions provide some Python built-in functions and some DTML-specific functions.

- abs(number)
- Return the absolute value of a number. The argument may be a plain or long integer or a floating point number. If the argument is a complex number, its magnitude is returned.
- chr(integer)
- Return a string of one character whose ASCII code
is the integer, e.g.,
`chr(97)`

returns the string`a`

. This is the inverse of ord(). The argument must be in the range 0 to 255, inclusive;`ValueError`

will be raised if the integer is outside that range. - DateTime()
- Returns a Zope
`DateTime`

object given constructor arguments. See the DateTime API reference for more information on constructor arguments. - divmod(number, number)
- Take two numbers as arguments and return
a pair of numbers consisting of their quotient and remainder when
using long division. With mixed operand types, the rules for
binary arithmetic operators apply. For plain and long integers,
the result is the same as
`(a / b, a % b)`

. For floating point numbers the result is`(q, a % b)`

, where*q*is usually`math.floor(a / b)`

but may be 1 less than that. In any case`q * b + a % b`

is very close to*a*, if`a % b`

is non-zero it has the same sign as*b*, and`0 <= abs(a % b) < abs(b)`

. - float(number)
- Convert a string or a number to floating
point. If the argument is a string, it must contain a possibly
signed decimal or floating point number, possibly embedded in
whitespace; this behaves identical to
`string.atof(number)`

. Otherwise, the argument may be a plain or long integer or a floating point number, and a floating point number with the same value (within Python's floating point precision) is returned. - getattr(object, string)
- Return the value of the named
attributed of object. name must be a string. If the string is the
name of one of the object's attributes, the result is the value of
that attribute. For example,
`getattr(x, "foobar")`

is equivalent to`x.foobar`

. If the named attribute does not exist, default is returned if provided, otherwise`AttributeError`

is raised. - getitem(variable, render=0)
- Returns the value of a DTML variable.
If
`render`

is true, the variable is rendered. See the`render`

function. - hasattr(object, string)
- The arguments are an object and a string. The result is 1 if the string is the name of one of the object's attributes, 0 if not. (This is implemented by calling getattr(object, name) and seeing whether it raises an exception or not.)
- hash(object)
- Return the hash value of the object (if it has one). Hash values are integers. They are used to quickly compare dictionary keys during a dictionary lookup. Numeric values that compare equal have the same hash value (even if they are of different types, e.g. 1 and 1.0).
- has_key(variable)
- Returns true if the DTML namespace contains the named variable.
- hex(integer)
- Convert an integer number (of any size) to a
hexadecimal string. The result is a valid Python expression. Note: this
always yields an unsigned literal, e.g. on a 32-bit machine,
`hex(-1)`

yields`0xffffffff`

. When evaluated on a machine with the same word size, this literal is evaluated as -1; at a different word size, it may turn up as a large positive number or raise an`OverflowError`

exception. - int(number)
- Convert a string or number to a plain integer. If
the argument is a string, it must contain a possibly signed
decimal number representable as a Python integer, possibly
embedded in whitespace; this behaves identical to
`string.atoi(number[, radix]`

). The`radix`

parameter gives the base for the conversion and may be any integer in the range 2 to 36. If`radix`

is specified and the number is not a string,`TypeError`

is raised. Otherwise, the argument may be a plain or long integer or a floating point number. Conversion of floating point numbers to integers is defined by the C semantics; normally the conversion truncates towards zero. - len(sequence)
- Return the length (the number of items) of an object. The argument may be a sequence (string, tuple or list) or a mapping (dictionary).
- max(s)
- With a single argument s, return the largest item of a non-empty sequence (e.g., a string, tuple or list). With more than one argument, return the largest of the arguments.
- min(s)
- With a single argument s, return the smallest item of a non-empty sequence (e.g., a string, tuple or list). With more than one argument, return the smallest of the arguments.
- namespace([name=value]...)
- Returns a new DTML namespace object.
Keyword argument
`name=value`

pairs are pushed into the new namespace. - oct(integer)
- Convert an integer number (of any size) to an octal
string. The result is a valid Python expression. Note: this always
yields an unsigned literal, e.g. on a 32-bit machine,
`oct(-1)`

yields`037777777777`

. When evaluated on a machine with the same word size, this literal is evaluated as -1; at a different word size, it may turn up as a large positive number or raise an OverflowError exception. - ord(character)
- Return the ASCII value of a string of one
character. E.g.,
`ord("a")`

returns the integer 97. This is the inverse of`chr()`

. - pow(x, y [,z])
- Return
*x*to the power*y*; if*z*is present, return*x*to the power*y*, modulo*z*(computed more efficiently than`pow(x, y) % z`

). The arguments must have numeric types. With mixed operand types, the rules for binary arithmetic operators apply. The effective operand type is also the type of the result; if the result is not expressible in this type, the function raises an exception; e.g.,`pow(2, -1)`

or`pow(2, 35000)`

is not allowed. - range([start,] stop [,step])
- This is a versatile function to
create lists containing arithmetic progressions. The arguments
must be plain integers. If the step argument is omitted, it
defaults to 1. If the start argument is omitted, it defaults to
0. The full form returns a list of plain integers
`[start, start + step, start + 2 * step, ...]`

. If step is positive, the last element is the largest`start + i * step`

less than*stop*; if*step*is negative, the last element is the largest`start + i * step`

greater than*stop*.*step*must not be zero (or else`ValueError`

is raised). - round(x [,n])
- Return the floating point value
*x*rounded to*n*digits after the decimal point. If n is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus n; if two multiples are equally close, rounding is done away from 0 (so e.g. round(0.5) is 1.0 and round(-0.5) is -1.0). - render(object)
- Render
`object`

. For DTML objects this evaluates the DTML code with the current namespace. For other objects, this is equivalent to`str(object)`

. - reorder(s [,with] [,without])
- Reorder the items in s according
to the order given in
`with`

and without the items mentioned in`without`

. Items from s not mentioned in with are removed. s, with, and without are all either sequences of strings or sequences of key-value tuples, with ordering done on the keys. This function is useful for constructing ordered select lists. - SecurityCalledByExecutable()
- Return a true if the current object (e.g. DTML document or method) is being called by an executable (e.g. another DTML document or method, a script or a SQL method).
- SecurityCheckPermission(permission, object)
- Check whether the
security context allows the given permission on the given
object. For example,
`SecurityCheckPermission("Add Documents, Images, and Files", this())`

would return true if the current user was authorized to create documents, images, and files in the current location. - SecurityGetUser()
- Return the current user object. This is
normally the same as the
`REQUEST.AUTHENTICATED_USER`

object. However, the`AUTHENTICATED_USER`

object is insecure since it can be replaced. - SecurityValidate([object] [,parent] [,name] [,value])
- Return
true if the value is accessible to the current user.
`object`

is the object the value was accessed in,`parent`

is the container of the value, and`name`

is the named used to access the value (for example, if it was obtained via`getattr`

). You may omit some of the arguments, however it is best to provide all available arguments. - SecurityValidateValue(object)
- Return true if the object is
accessible to the current user. This function is the same as
calling
`SecurityValidate(None, None, None, object)`

. - str(object)
- Return a string containing a nicely printable representation of an object. For strings, this returns the string itself.
- test(condition, result [,condition, result]... [,default])
- Takes one or more condition, result pairs and returns the result of the first true condition. Only one result is returned, even if more than one condition is true. If no condition is true and a default is given, the default is returned. If no condition is true and there is no default, None is returned.
- unichr(number)
- Return a unicode string representing the value of number as a unicode character. This is the inverse of ord() for unicode characters.
- unicode(string[, encoding[, errors ] ])
- Decodes string using the codec for encoding. Error handling is done according to errors. The default behavior is to decode UTF-8 in strict mode, meaning that encoding errors raise ValueError.

- None
- The
`None`

object is equivalent to the Python built-in object`None`

. This is usually used to represent a Null or false value.

"`string`

module":string.py

"`random`

module":random.py

"`math`

module":math.py

"`sequence`

module":sequence.py