Docs for FORM

[ Python Tutorial ] [ Python Libraries ] [ web2py epydoc ]

Description

<type 'type'> extends (<class 'gluon.html.DIV'>,)


    Examples:

    >>> from validators import IS_NOT_EMPTY
    >>> form=FORM(INPUT(_name="test", requires=IS_NOT_EMPTY()))
    >>> form.xml()
    '<form action="#" enctype="multipart/form-data" method="post"><input name="test" type="text" /></form>'


    a FORM is container for INPUT, TEXTAREA, SELECT and other helpers

    form has one important method::

        form.accepts(request.vars, session)

    if form is accepted (and all validators pass) form.vars contains the
    accepted vars, otherwise form.errors contains the errors.
    in case of errors the form is modified to present the errors to the user.

Attributes


FORM.REDIRECT_JS	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

FORM.__add__	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.__class__	<type 'type'> extends (<type 'object'>,) belongs to class <type 'type'> type(object) -> the object's type type(name, bases, dict) -> a new type

FORM.__delattr__	<type 'wrapper_descriptor'> belongs to class <type 'wrapper_descriptor'> x.__delattr__('name') <==> del x.name

FORM.__delitem__	<type 'instancemethod'> belongs to class <type 'instancemethod'> Deletes attribute with name 'i' or component #i. Args: i: index. If i is a string: the name of the attribute otherwise references to number of the component

FORM.__dict__	<type 'dictproxy'> belongs to class <type 'dictproxy'>

FORM.__doc__	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

FORM.__format__	<type 'method_descriptor'> belongs to class <type 'method_descriptor'> default object formatter

FORM.__getattribute__	<type 'wrapper_descriptor'> belongs to class <type 'wrapper_descriptor'> x.__getattribute__('name') <==> x.name

FORM.__getitem__	<type 'instancemethod'> belongs to class <type 'instancemethod'> Gets attribute with name 'i' or component #i. If attribute 'i' is not found returns None Args: i: index. If i is a string: the name of the attribute otherwise references to number of the component

FORM.__hash__	<type 'wrapper_descriptor'> belongs to class <type 'wrapper_descriptor'> x.__hash__() <==> hash(x)

FORM.__init__	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.__len__	<type 'instancemethod'> belongs to class <type 'instancemethod'> Returns the number of included components

FORM.__module__	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

FORM.__mul__	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.__new__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> T.__new__(S, ...) -> a new object with type S, a subtype of T

FORM.__nonzero__	<type 'instancemethod'> belongs to class <type 'instancemethod'> Always returns True

FORM.__reduce__	<type 'method_descriptor'> belongs to class <type 'method_descriptor'> helper for pickle

FORM.__reduce_ex__	<type 'method_descriptor'> belongs to class <type 'method_descriptor'> helper for pickle

FORM.__repr__	<type 'wrapper_descriptor'> belongs to class <type 'wrapper_descriptor'> x.__repr__() <==> repr(x)

FORM.__setattr__	<type 'wrapper_descriptor'> belongs to class <type 'wrapper_descriptor'> x.__setattr__('name', value) <==> x.name = value

FORM.__setitem__	<type 'instancemethod'> belongs to class <type 'instancemethod'> Sets attribute with name 'i' or component #i. Args: i: index. If i is a string: the name of the attribute otherwise references to number of the component value: the new value

FORM.__sizeof__	<type 'method_descriptor'> belongs to class <type 'method_descriptor'> __sizeof__() -> int size of object in memory, in bytes

FORM.__str__	<type 'instancemethod'> belongs to class <type 'instancemethod'> str(COMPONENT) returns COMPONENT.xml()

FORM.__subclasshook__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> Abstract classes can override this to customize issubclass(). This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

FORM.__weakref__	<type 'getset_descriptor'> belongs to class <type 'getset_descriptor'> list of weak references to the object (if defined)

FORM._fixup	<type 'instancemethod'> belongs to class <type 'instancemethod'> Handling of provided components. Nothing to fixup yet. May be overridden by subclasses, eg for wrapping some components in another component or blocking them.

FORM._postprocessing	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM._setnode	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM._traverse	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM._validate	<type 'instancemethod'> belongs to class <type 'instancemethod'> nothing to validate yet. May be overridden by subclasses

FORM._wrap_components	<type 'instancemethod'> belongs to class <type 'instancemethod'> helper for _fixup. Checks if a component is in allowed_parents, otherwise wraps it in wrap_parent Args: allowed_parents: (tuple) classes that the component should be an instance of wrap_parent: the class to wrap the component in, if needed wrap_lambda: lambda to use for wrapping, if needed

FORM._xml	<type 'instancemethod'> belongs to class <type 'instancemethod'> Helper for xml generation. Returns separately: - the component attributes - the generated xml of the inner components Component attributes start with an underscore ('_') and do not have a False or None value. The underscore is removed. A value of True is replaced with the attribute name. Returns: tuple: (attributes, components)

FORM.accepts	<type 'instancemethod'> belongs to class <type 'instancemethod'> kwargs is not used but allows to specify the same interface for FORM and SQLFORM

FORM.add_button	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.add_class	<type 'instancemethod'> belongs to class <type 'instancemethod'> add a class to _class attribute

FORM.append	<type 'instancemethod'> belongs to class <type 'instancemethod'> list style appending of components Examples: >>> a=DIV() >>> a.append(SPAN('x')) >>> print a <div><span>x</span></div>

FORM.as_dict	<type 'instancemethod'> belongs to class <type 'instancemethod'> EXPERIMENTAL Sanitize is naive. It should catch any unsafe value for client retrieval.

FORM.as_json	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.as_xml	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.as_yaml	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.assert_status	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.confirm	<type 'function'> belongs to class <type 'function'>

FORM.element	<type 'instancemethod'> belongs to class <type 'instancemethod'> Finds the first component that matches the supplied attribute dictionary, or None if nothing could be found Also the components of the components are searched.

FORM.elements	<type 'instancemethod'> belongs to class <type 'instancemethod'> Find all components that match the supplied attribute dictionary, or None if nothing could be found All components of the components are searched. Examples: >>> a = DIV(DIV(SPAN('x'),3,DIV(SPAN('y')))) >>> for c in a.elements('span',first_only=True): c[0]='z' >>> print a <div><div><span>z</span>3<div><span>y</span></div></div></div> >>> for c in a.elements('span'): c[0]='z' >>> print a <div><div><span>z</span>3<div><span>z</span></div></div></div> It also supports a syntax compatible with jQuery Examples: >>> a=TAG('<div><span><a id="1-1" u:v=$>hello</a></span><p class="this is a test">world</p></div>') >>> for e in a.elements('div a#1-1, p.is'): print e.flatten() hello world >>> for e in a.elements('#1-1'): print e.flatten() hello >>> a.elements('a[u:v=$]')[0].xml() '<a id="1-1" u:v="$">hello</a>' >>> a=FORM( INPUT(_type='text'), SELECT(range(1)), TEXTAREA() ) >>> for c in a.elements('input, select, textarea'): c['_disabled'] = 'disabled' >>> a.xml() '<form action="#" enctype="multipart/form-data" method="post"><input disabled="disabled" type="text" /><select disabled="disabled"><option value="0">0</option></select><textarea cols="40" disabled="disabled" rows="10"></textarea></form>' Elements that are matched can also be replaced or removed by specifying a "replace" argument (note, a list of the original matching elements is still returned as usual). Examples: >>> a = DIV(DIV(SPAN('x', _class='abc'), DIV(SPAN('y', _class='abc'), SPAN('z', _class='abc')))) >>> b = a.elements('span.abc', replace=P('x', _class='xyz')) >>> print a <div><div><p class="xyz">x</p><div><p class="xyz">x</p><p class="xyz">x</p></div></div></div> "replace" can be a callable, which will be passed the original element and should return a new element to replace it. Examples: >>> a = DIV(DIV(SPAN('x', _class='abc'), DIV(SPAN('y', _class='abc'), SPAN('z', _class='abc')))) >>> b = a.elements('span.abc', replace=lambda el: P(el[0], _class='xyz')) >>> print a <div><div><p class="xyz">x</p><div><p class="xyz">y</p><p class="xyz">z</p></div></div></div> If replace=None, matching elements will be removed completely. Examples: >>> a = DIV(DIV(SPAN('x', _class='abc'), DIV(SPAN('y', _class='abc'), SPAN('z', _class='abc')))) >>> b = a.elements('span', find='y', replace=None) >>> print a <div><div><span class="abc">x</span><div><span class="abc">z</span></div></div></div> If a "find_text" argument is specified, elements will be searched for text components that match find_text, and any matching text components will be replaced (find_text is ignored if "replace" is not also specified). Like the "find" argument, "find_text" can be a string or a compiled regex. Examples: >>> a = DIV(DIV(SPAN('x', _class='abc'), DIV(SPAN('y', _class='abc'), SPAN('z', _class='abc')))) >>> b = a.elements(find_text=re.compile('x\|y\|z'), replace='hello') >>> print a <div><div><span class="abc">hello</span><div><span class="abc">hello</span><span class="abc">hello</span></div></div></div> If other attributes are specified along with find_text, then only components that match the specified attributes will be searched for find_text. Examples: >>> a = DIV(DIV(SPAN('x', _class='abc'), DIV(SPAN('y', _class='efg'), SPAN('z', _class='abc')))) >>> b = a.elements('span.efg', find_text=re.compile('x\|y\|z'), replace='hello') >>> print a <div><div><span class="abc">x</span><div><span class="efg">hello</span><span class="abc">z</span></div></div></div>

FORM.flatten	<type 'instancemethod'> belongs to class <type 'instancemethod'> Returns the text stored by the DIV object rendered by the render function the render function must take text, tagname, and attributes `render=None` is equivalent to `render=lambda text, tag, attr: text` Examples: >>> markdown = lambda text,tag=None,attributes={}: {None: re.sub('\s+',' ',text), 'h1':'#'+text+'\n\n', 'p':text+'\n'}.get(tag,text) >>> a=TAG('<h1>Header</h1><p>this is a test</p>') >>> a.flatten(markdown) '#Header\n\nthis is a test\n'

FORM.hidden_fields	<type 'instancemethod'> belongs to class <type 'instancemethod'>

FORM.insert	<type 'instancemethod'> belongs to class <type 'instancemethod'> List-style inserting of components Examples: >>> a=DIV() >>> a.insert(0,SPAN('x')) >>> print a <div><span>x</span></div>

FORM.process	<type 'instancemethod'> belongs to class <type 'instancemethod'> Perform the .validate() method but returns the form Usage in controllers:: # directly on return def action(): #some code here return dict(form=FORM(...).process(...)) You can use it with FORM, SQLFORM or FORM based plugins:: # response.flash messages def action(): form = SQLFORM(db.table).process(message_onsuccess='Sucess!') return dict(form=form) # callback function # callback receives True or False as first arg, and a list of args. def my_callback(status, msg): response.flash = "Success! "+msg if status else "Errors occured" # after argument can be 'flash' to response.flash messages # or a function name to use as callback or None to do nothing. def action(): return dict(form=SQLFORM(db.table).process(onsuccess=my_callback)

FORM.regex_attr	<type '_sre.SRE_Pattern'> belongs to class <type '_sre.SRE_Pattern'> Compiled regular expression objects

FORM.regex_class	<type '_sre.SRE_Pattern'> belongs to class <type '_sre.SRE_Pattern'> Compiled regular expression objects

FORM.regex_id	<type '_sre.SRE_Pattern'> belongs to class <type '_sre.SRE_Pattern'> Compiled regular expression objects

FORM.regex_tag	<type '_sre.SRE_Pattern'> belongs to class <type '_sre.SRE_Pattern'> Compiled regular expression objects

FORM.remove_class	<type 'instancemethod'> belongs to class <type 'instancemethod'> remove a class from _class attribute

FORM.sibling	<type 'instancemethod'> belongs to class <type 'instancemethod'> Finds the first sibling component that match the supplied argument list and attribute dictionary, or None if nothing could be found

FORM.siblings	<type 'instancemethod'> belongs to class <type 'instancemethod'> Finds all sibling components that match the supplied argument list and attribute dictionary, or None if nothing could be found

FORM.tag	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

FORM.update	<type 'instancemethod'> belongs to class <type 'instancemethod'> dictionary like updating of the tag attributes

FORM.validate	<type 'instancemethod'> belongs to class <type 'instancemethod'> This function validates the form, you can use it instead of directly form.accepts. Usage: In controller:: def action(): form=FORM(INPUT(_name="test", requires=IS_NOT_EMPTY())) form.validate() #you can pass some args here - see below return dict(form=form) This can receive a bunch of arguments onsuccess = 'flash' - will show message_onsuccess in response.flash None - will do nothing can be a function (lambda form: pass) onfailure = 'flash' - will show message_onfailure in response.flash None - will do nothing can be a function (lambda form: pass) onchange = 'flash' - will show message_onchange in response.flash None - will do nothing can be a function (lambda form: pass) message_onsuccess message_onfailure message_onchange next = where to redirect in case of success any other kwargs will be passed for form.accepts(...)

FORM.xml	<type 'instancemethod'> belongs to class <type 'instancemethod'>