now() returns the current date and time as a date object.

utcnow() returns the current date and time as a date object in UTC.

date() creates a date object from the parameter passed in. date() supports from three parameters (year, month, day) upto seven parameters (year, month, day, hour, minute, second, microsecond).

timedelta returns an object that represents a timespan. timedelta allows from zero to three arguments specifying the numbers of days, seconds and microseconds. Passing negative values or values that are out of bounds (e.g. 24*60*60+1 seconds) is allowed. Arguments default to 0, i.e. timedelta() returns the timespan for "0 days, 0 seconds, 0 microseconds". In a boolean context this object is treated as false (i.e. bool(timedelta())) returns False). The following arithmetic operations are supported:

*   ``date`` + ``timedelta``
*   ``date`` - ``timedelta``
*   ``timedelta`` + ``timedelta``
*   ``timedelta`` - ``timedelta``
*   ``number`` * ``timedelta``
*   ``timedelta`` * ``number``
*   ``timedelta`` / ``number``
*   ``timedelta`` // ``int``

monthdelta returns an object that represents a timespan of a number of months. monthdelta allows from zero or one arguments. With zero arguments monthdelta returns the timespan for "0 months". In a boolean context this object is treated as false (i.e. bool(monthdelta())) or bool(monthdelta(0))) return False). The following arithmetic operations are supported:

*   ``date`` + ``monthdelta``
*   ``date`` - ``monthdelta``
*   ``monthdelta`` + ``monthdelta``
*   ``monthdelta`` - ``monthdelta``
*   ``int`` * ``monthdelta``
*   ``monthdelta`` // ``int``

For the operations involving date objects, if the resulting day falls out of the range of valid days for the target month, the last day for the target month will be used instead, i.e. <?print @(2000-01-31) + monthdelta(1)?> prints 2000-02-29 00:00:00.

vars() returns a dictionary containing all currently defined variables (i.e. variables passed to the template, defined via <?code?> tags or as loop variables).

random() returns a random float value between 0 (included) and 1 (excluded).

randrange(start, stop, step) returns a random integer value between start (included) and stop (excluded). step specifies the step size (i.e. when r is the random value, (r-start) % step will always be 0. step and start can be ommitted.

randchoice(seq) returns a random item from the sequence seq.

isundefined(foo) returns True if foo is Undefined, else False is returned:

data is <?if isundefined(data)?>undefined<?else?>defined<?end if?>!

isdefined(foo) returns False if foo is Undefined, else True is returned:

data is <?if isdefined(data)?>defined<?else?>undefined<?end if?>!

isnone(foo) returns True if foo is None, else False is returned:

data is <?if isnone(data)?>None<?else?>something else<?end if?>!

isbool(foo) returns True if foo is True or False, else False is returned.

isint(foo) returns True if foo is an integer object, else False is returned.

isfloat(foo) returns True if foo is a float object, else False is returned.

isstr(foo) returns True if foo is a string object, else False is returned.

isdate(foo) returns True if foo is a date object, else False is returned.

istimedelta(foo) returns True if foo is a timedelta object, else False is returned.

ismonthdelta(foo) returns True if foo is a monthdelta object, else False is returned.

islist(foo) returns True if foo is a list object, else False is returned.

isdict(foo) returns True if foo is a dictionary object, else False is returned.

iscolor(foo) returns True if foo is a color object, else False is returned.

bool(foo) converts foo to an boolean. I.e. True or False is returned according to the truth value of foo. Calling bool without arguments returns False.

int(foo) converts foo to an integer. foo can be a string, a float, a boolean or an integer. int can also be called with two arguments. In this case the first argument must be a string and the second is the number base for the conversion. Calling int without arguments returns 0.

float(foo) converts foo to a float. foo can be a string, a float, a boolean or an integer. Calling float without arguments returns 0.0.

str(foo) converts foo to a string. If foo is None or Undefined the result will be the empty string. For lists and dictionaries the exact format is undefined, but should follow Python's repr format. For color objects the result is a CSS expression (e.g. "#fff"). Calling str without arguments returns the empty string.

repr(foo) converts foo to a string representation that is useful for debugging proposes. The output is a constant expression that could be used to recreate the object.

asjson(foo) returns a JSON representation of the object foo.

fromjson(foo) decodes the JSON string foo and returns the resulting object.

asul4on(foo) returns the UL4ON representation of the object foo.

fromul4on(foo) decodes the UL4ON string foo and returns the resulting object.

get(k, v) returns the global variable named k if it exists, else v is returned. If v is not given, it defaults to None.

len(foo) returns the length of a string, or the number of items in a list or dictionary.

any(foo) returns True if any of the items in the iterable foo is true. Otherwise False is returns. If foo is empty False is returned.

all(foo) returns True if all of the items in the iterable foo are true. Otherwise False is returns. If foo is empty True is returned.

Iterates through items of the argument (which must be iterable, i.e. a string, a list or dictionary) and gives information about whether the item is the first and/or last in the iterable. For example the following code:

<?for (first, last, c) in isfirstlast("foo")?>
    <?if first?>[<?end if?>
    (<?print c?>)
    <?if last?>]<?end if?>
<?end for?>

prints:

[(f)(o)(o)]

Iterates through items of the argument (which must be iterable, i.e. a string, a list or dictionary) and gives information about whether the item is the first in the iterable. For example the following code:

<?for (first, c) in isfirst("foo")?>
    <?if first?>[<?end if?>
    (<?print c?>)
<?end for?>

prints:

[(f)(o)(o)

Iterates through items of the argument (which must be iterable, i.e. a string, a list or dictionary) and gives information about whether the item is the last in the iterable. For example the following code:

<?for (last, c) in islast("foo")?>
    (<?print c?>)
    <?if last?>]<?end if?>
<?end for?>

prints:

(f)(o)(o)]

Enumerates the items of the argument (which must be iterable, i.e. a string, a list or dictionary). For example the following code:

<?for (i, c) in enumerate("foo")?>
    (<?print c?>=<?print i?>)
<?end for?>

prints:

(f=0)(o=1)(o=2)

This function is a combination of isfirstlast and enumerate. It iterates through items of the argument (which must be iterable, i.e. a string, a list or dictionary) and gives information about whether the item is the first and/or last in the iterable and its position. For example the following code:

<?for (index, first, last, c) in enumfl("foo")?>
    <?if first?>[<?end if?>
    (<?print c?>=<?print index?>)
    <?if last?>]<?end if?>
<?end for?>

prints:

[(f=0)(o=1)(o=2)]

xmlescape takes a string as an argument. It returns a new string where the characters &, <, >, ' and " are replaced with the appropriate XML entity or character references. For example:

<?print xmlescape("<'foo' & 'bar'>")?>

prints:

``<'foo' & ;'bar&#39>``

If the argument is not a string, it will be converted to a string first.

<?printx foo?> is a shortcut for <?print xmlescape(foo)?>.

min returns the minimum value of its two or more arguments. If it's called with one argument, this argument must be iterable and min returns the minimum value of this argument.

max returns the maximum value of its two or more arguments. If it's called with one argument, this argument must be iterable and max returns the maximum value of this argument.

sorted returns a sorted list with the items from it's argument. For example:

<?for c in sorted('bar')?><?print c?><?end for?>

prints:

abr

Supported arguments are iterable objects, i.e. strings, lists, dictionaries and colors.

chr(x) returns a one-character string with a character with the codepoint x. x must be an integer. For example <?print chr(0x61)?> outputs a.

The argument for ord must be a one-character string. ord returns the codepoint of that character as an integer. For example <?print ord('a')?> outputs 97.

Return the hexadecimal representation of the integer argument (with a leading 0x). For example <?print hex(42)?> outputs 0x2a.

Return the octal representation of the integer argument (with a leading 0o). For example <?print oct(42)?> outputs 0o52.

Return the binary representation of the integer argument (with a leading 0b). For example <?print bin(42)?> outputs 0b101010.

range returns an object that can be iterated and will produce consecutive integers up to the specified argument. With two arguments the first is the start value and the second is the stop value. With three arguments the third one is the step size (which can be negative). For example the following template:

<?for i in range(2, 10, 2)?>(<?print i?>)<?end for?>

outputs:

(2)(4)(6)(8)

type returns the type of the object as a string. Possible return values are "none", "bool", "int", "float", "str", "list", "dict", "date", "color" and "template". (If the type isn't recognized None is returned.)

rgb returns a color object. It can be called with

• three arguments, the red, green and blue values. The alpha value will be set to 255;

• four arguments, the red, green, blue and alpha values.

random returns a random floating point number between 0 and 1.

randchoice returns a random item from its argument (which must be list or string)

random returns a random item from its argument (which must be list or string).

The upper method of strings returns an uppercase version of the string for which it's called:

<?print 'foo'.upper()?>

prints:

FOO

The lower method of strings returns an lowercase version of the string for which it's called.

The capitalize method of strings returns a copy of the string for with its first letter capitalized.

x.startswith(y) returns True if the string x starts with the string y and False otherwise.

x.endswith(y) returns True if the string x ends with the string y and False otherwise.

The string method strip returns a copy of the string with leading and trailing whitespace removed. If an argument chars is given and not None, characters in chars will be removed instead.

The string method lstrip returns a copy of the string with leading whitespace removed. If an argument chars is given and not None, characters in chars will be removed instead.

The string method rstrip returns a copy of the string with trailing whitespace removed. If an argument chars is given and not None, characters in chars will be removed instead.

The string method split splits the string into separate "words" and returns the resulting list. Without any arguments, the string is split on whitespace characters. With one argument the argument specifies the separator to use. The second optional argument specifies the maximum number of splits to do.

The string method rsplit works like split, except that splitting starts from the end (which is only relevant when the maximum number of splits is given).

This method searches for a substring of the string or an item in a list and returns the position of the first appearance of the substring/item or -1 if the string/item can't be found. For example "foobar".find("bar") returns 3. The optional second and third argument specify the start and end position for the search.

This method works like find but searches from the end.

This string method replace has two arguments. It returns a new string where each occurrence of the first argument is replaced by the second argument.

get is a dictionary method. d.get(k, v) returns d[k] if the key k is in d, else v is returned. If v is not given, it defaults to None.

join is a string method. It returns a concatentation of the strings in the argument sequence with the string itself as the separator, i.e.:

<?print "+".join(["1", "2", "3", "4"])?>

outputs:

1+2+3+4

The renders method of template objects renders the template and returns the output as a string. The parameter can be passed via keyword argument or via the ** syntax:

<?code output = template.renders(a=17, b=23)?>
<?code data = {'a': 17, 'b': 23)?>
<?code output = template.renders(**data)?>

isoformat is a date method. It returns the date object in ISO 8601 format, i.e.:

<?print now().isoformat()?>

might output:

2010-02-22T18:30:29.569639

mimeformat is a date method. It returns the date object in MIME format (assuming the date object is in UTC), i.e.:

<?print utcnow().mimeformat()?>

might output:

Mon, 22 Feb 2010 17:38:40 GMT

Those methods are date methods. They return a specific attribute of a date object. For example the following reproduces the mimeformat output from above (except for the linefeeds of course):

<?code weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']?>
<?code months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']?>
<?code t = @(2010-02-22T17:38:40.123456)?>
<?print weekdays[t.weekday()]?>,
<?print format(t.day(), '02')?>
<?print months[t.month()-1]?>
<?print format(t.year(), '04')?>
<?print format(t.hour(), '02')?>:
<?print format(t.minute(), '02')?>:
<?print format(t.second(), '02')?>.
<?print format(t.microsecond(), '06')?> GMT

week is a date method. This method returns the week number of the year. It supports one argument: the weekday number (0 for Monday, ... 6 for Sunday) that should be considered the start day of the week. All days in a new year preceding the first week start day are considered to be in week 0. The week start day defaults to 0 (Monday).

yearday is a date method. It returns the number of days since the beginning of the year, so:

<?print @(2010-01-01).yearday()?>

prints 1 and:

<?print @(2010-12-31).yearday()?>

prints 365.