functions: DTML Functions

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

  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":DateTime.py 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.

  Attributes

    None -- The 'None' object is equivalent to the Python built-in object
    'None'.  This is usually used to represent a Null or false value.

  See Also

    "'string' module":string.py

    "'random' module":random.py

    "'math' module":math.py

    "'sequence' module":sequence.py

    "Built-in Python Functions":http://www.python.org/doc/current/lib/built-in-funcs.html