pyams/pyams_form: comparison src/pyams

equal deleted inserted replaced

-:ba372884335f
+:c435de184bda
 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
 # FOR A PARTICULAR PURPOSE.
 #
-__docformat__ = 'restructuredtext'
+"""PyAMS_form.form module
+This module is the core of PyAMS_form package; it provides additions to form management as
+provided by z3c.form package.
+"""
+import json
 import logging
-logger = logging.getLogger('PyAMS (form)')
-import json
 import transaction
 import venusian
 from persistent import IPersistent
 from pyramid.decorator import reify
 from pyramid.events import subscriber
 from pyramid.response import Response
 from pyramid_chameleon.interfaces import IChameleonTranslate
 from pyramid_zope_request import PyramidPublisherRequest, PyramidToPublisher
 from z3c.form.button import Buttons
-from z3c.form.form import AddForm as BaseAddForm, DisplayForm as BaseDisplayForm, EditForm as BaseEditForm, Form, \
+from z3c.form.form import AddForm as BaseAddForm, DisplayForm as BaseDisplayForm, \
-applyChanges
+EditForm as BaseEditForm, Form, applyChanges
 from z3c.form.interfaces import DISPLAY_MODE, IErrorViewSnippet, IMultipleErrors
 from zope.component import queryUtility
-from zope.interface import Interface, alsoProvides, classImplements, implementer, Invalid
+from zope.interface import Interface, Invalid, alsoProvides, classImplements, implementer
 from zope.lifecycleevent import Attributes, ObjectCreatedEvent
 from zope.location import locate
 from zope.publisher.interfaces.browser import IBrowserRequest
 from zope.schema.fieldproperty import FieldProperty
 from zope.schema.interfaces import ValidationError
 from pyams_form.group import GroupsBasedForm
 from pyams_form.interfaces import get_form_weight
 from pyams_form.interfaces.form import FormCreatedEvent, IAJAXForm, ICustomUpdateSubForm, IForm, \
-IFormContextPermissionChecker, IFormCreatedEvent, IFormLayer, IInnerForm, IInnerSubForm, IInnerTabForm
+IFormContextPermissionChecker, IFormCreatedEvent, IFormLayer, IInnerForm, IInnerSubForm, \
+IInnerTabForm
 from pyams_form.interfaces.form import FormObjectCreatedEvent, FormObjectModifiedEvent
 from pyams_form.interfaces.form import IAddFormButtons, IEditFormButtons, IModalAddFormButtons, \
 IModalDisplayFormButtons, IModalEditFormButtons
 from pyams_i18n.interfaces import II18n
 from pyams_pagelet.interfaces import PageletCreatedEvent
 from pyams_template.interfaces import IContentTemplate, ILayoutTemplate
 from pyams_utils.adapter import ContextRequestViewAdapter, adapter_config
 from pyams_utils.interfaces import FORBIDDEN_PERMISSION, ICacheKeyValue
 from pyams_utils.url import absolute_url
-from pyams_form import _
+__docformat__ = 'restructuredtext'
+from pyams_form import _    # pylint: disable=ungrouped-imports
+LOGGER = logging.getLogger('PyAMS (form)')
 REDIRECT_STATUS_CODES = (300, 301, 302, 303, 304, 305, 307)
 @PyramidToPublisher(IBrowserRequest)
 alsoProvides(req, self.layer)
 request.registry.notify(FormCreatedEvent(self))
 @property
 def title(self):
+"""Get form's title"""
 registry = self.request.registry
 adapter = registry.queryMultiAdapter((self.context, self.request, self), IContentTitle)
 if adapter is None:
 adapter = registry.queryAdapter(self.context, IContentTitle)
 if adapter is not None:
 return adapter.title
-else:
+return II18n(self.context).query_attribute('title', request=self.request)
-return II18n(self.context).query_attribute('title', request=self.request)
 def check_mode(self):
+"""Check form's mode according to context's permissions"""
 content = self.getContent()
 # check form permission to get form mode
 if self.edit_permission and not self.request.has_permission(self.edit_permission, content):
 self.mode = DISPLAY_MODE
 return
 # check form mode based on context checker
 registry = self.request.registry
 permission = None
-checker = registry.queryMultiAdapter((content, self.request, self), IFormContextPermissionChecker)
+checker = registry.queryMultiAdapter((content, self.request, self),
+IFormContextPermissionChecker)
 if checker is None:
 checker = registry.queryAdapter(content, IFormContextPermissionChecker)
 if checker is not None:
 permission = checker.edit_permission
 if permission and (permission != self.edit_permission):
-if (permission == FORBIDDEN_PERMISSION) or not self.request.has_permission(permission, content):
+if (permission == FORBIDDEN_PERMISSION) or not self.request.has_permission(permission,
+content):
 self.mode = DISPLAY_MODE
 def update(self):
+"""Update form and all it's subforms"""
 # check form mode
 self.check_mode()
 # update form and sub-forms
-[subform.update() for subform in self.subforms]
+[subform.update() for subform in self.subforms]  # pylint: disable=expression-not-assigned
-[tabform.update() for tabform in self.tabforms]
+[tabform.update() for tabform in self.tabforms]  # pylint: disable=expression-not-assigned
 Form.update(self)
 # savepoint is required for each inner component to be persisted!!
 transaction.savepoint()
 def updateWidgets(self, prefix=None):
+"""Update form's widgets"""
 super(BaseForm, self).updateWidgets(prefix)
 if not self._groups:
 self.updateGroups()
 def get_form_action(self):
+"""Get action associated with form"""
 return self.action
 @reify
 def subforms(self):
+"""Get subforms adapters associated with this form"""
 registry = self.request.registry
 return sorted((adapter[1]
-for adapter in registry.getAdapters((self.context, self.request, self), IInnerSubForm)),
+for adapter in
+registry.getAdapters((self.context, self.request, self), IInnerSubForm)),
 key=get_form_weight)
 @reify
 def tabforms(self):
+"""Get tabforms adapters associated with this form"""
 registry = self.request.registry
 return sorted((adapter[1]
-for adapter in registry.getAdapters((self.context, self.request, self), IInnerTabForm)),
+for adapter in
+registry.getAdapters((self.context, self.request, self), IInnerTabForm)),
 key=get_form_weight)
 @property
 def forms(self):
+"""Get all forms associated with this form, including the form itself"""
 return [self, ] + self.subforms + self.tabforms
 def get_forms(self, include_self=True):
+"""Get forms associated with this form; if *include_self* argument is True, self is also
+included into results list
+"""
 if include_self:
 yield self
 for group in self.groups:
 for subform in group.get_forms():
 yield subform
 for form in self.tabforms:
 yield form
 @reify
 def warn_on_change(self):
+"""JSON boolean value specifying "warn on change" flag"""
 if self._warn_on_change is True:
 return 'true'
-elif self._warn_on_change is False:
+if self._warn_on_change is False:
 return 'false'
-else:
+return None
-return None
 @property
 def is_dialog(self):
+"""Boolean flag specifying if current form should be displayed in a modal dialog box"""
 return IDialog.providedBy(self)
 def get_widget_callback(self, widget):
+"""Get callback associated with a given widget"""
 return (self.callbacks or {}).get(widget)
 # Default z3c.form methods
 @property
 def errors(self):
+"""Get form's errors"""
 result = []
 for form in self.forms:
 result.extend(form.widgets.errors)
 return result
 def add_error(self, error, widget, status=None):
+"""Add error to current list of form's errors"""
 if isinstance(error, str):
 error = Invalid(error)
 if isinstance(widget, str):
 widget = self.widgets[widget]
 snippet = self.request.registry.getMultiAdapter((error, self.request, widget,
 if not self.status:
 self.status = translate(status or self.formErrorsMessage)
 self.status += '\n{0}'.format(translate(error.args[0]))
 def update_content(self, content, data):
+"""Update content properties with given data"""
 changes = applyChanges(self, content, data.get(self, data))
 for subform in self.get_forms(include_self=False):
 if subform.mode == DISPLAY_MODE:
 continue
 subform_update = ICustomUpdateSubForm(subform, None)
 if subform_update is not None:
-updates = subform_update.update_content(subform.getContent(), data.get(subform, data))
+# pylint: disable=assignment-from-no-return
+updates = subform_update.update_content(subform.getContent(),
+data.get(subform, data))
 if isinstance(updates, dict):
 changes.update(updates)
 else:
 changes.update(applyChanges(subform, subform.getContent(), data.get(subform, data)))
 return changes
 def render(self):
+"""Render form using content template
+Several default templates are defined for all base forms interfaces.
+"""
 request = self.request
 if isinstance(request, PyramidPublisherRequest):
-request = request._request
+request = request._request  # pylint: disable=protected-access
 cdict = {
 'context': self.context,
 'request': request,
 'view': self,
 'translate': queryUtility(IChameleonTranslate)
 registry = request.registry
 template = registry.queryMultiAdapter((self, request, self.context), IContentTemplate)
 if template is None:
 template = registry.getMultiAdapter((self, request), IContentTemplate)
 return template(**cdict)
-return self.template(**cdict)
+return self.template(**cdict)  # pylint: disable=not-callable
-def __call__(self, **kwargs):
+def __call__(self, **kwargs):  # pylint: disable=arguments-differ
 self.update()
 if self.request.response.status_code in REDIRECT_STATUS_CODES:
 return Response('')
 request = self.request
 layout = registry.queryMultiAdapter((self, request, self.context),
 ILayoutTemplate)
 if layout is None:
 layout = registry.getMultiAdapter((self, request), ILayoutTemplate)
 return Response(layout(**cdict))
-return Response(self.layout(**cdict))
+return Response(self.layout(**cdict))  # pylint: disable=not-callable
 def get_skin(self, request=None):
+"""Get current skin applied to request"""
+if request is None:
+request = self.request
 return request.annotations.get('__skin__')
 @implementer(IAJAXForm)
 class AJAXForm(BaseForm):
-"""AJAX form base class"""
+# pylint: disable=abstract-method
+"""AJAX form base class
+An AJAX form is a form which is submitted through an AJAX call; submit response is
+returned as a JSON object which is handled by MyAMS.
+"""
 ajax_handler = FieldProperty(IAJAXForm['ajax_handler'])
 form_options = FieldProperty(IAJAXForm['form_options'])
 form_target = FieldProperty(IAJAXForm['form_target'])
 ajax_callback = FieldProperty(IAJAXForm['ajax_callback'])
 def get_form_action(self):
+"""Get form's target action URL"""
 return absolute_url(self.context, self.request, self.request.view_name)
 def get_form_options(self):
+"""Get form's options"""
 return json.dumps(self.form_options) if self.form_options else None
 def get_ajax_handler(self):
+"""Get form's AJAX handler"""
 return absolute_url(self.context, self.request, self.ajax_handler)
 def get_ajax_errors(self, ajax_errors=None):
-"""Extract form errors in AJAX format"""
+"""Extract form errors in JSON format"""
 translate = self.request.localizer.translate
 errors = {
 'status': u'error',
 'error_message': translate(self.status)
 }
 registry = self.request.registry
 for error in (ajax_errors or self.errors):
 if isinstance(error, Exception):
-error = registry.getMultiAdapter((error, self.request, None, None, self, self.request),
+error = registry.getMultiAdapter(
-IErrorViewSnippet)
+(error, self.request, None, None, self, self.request),
+IErrorViewSnippet)
 error.update()
 if IMultipleErrors.providedBy(error.error):
 for inner_error in error.error.errors:
 if hasattr(inner_error, 'widget'):
 widget = inner_error.widget
 #
 # Add forms
 #
 class AddForm(AJAXForm, BaseAddForm):
+# pylint: disable=abstract-method
 """Add form base class"""
 prefix = 'add_form.'
 buttons = Buttons(IAddFormButtons)
 self.actions['add'].addClass('btn-primary')
 def createAndAdd(self, data):
 registry = self.request.registry
 # create object
-object = self.create(data.get(self, data))
+obj = self.create(data.get(self, data))
-if IPersistent.providedBy(object):
+if IPersistent.providedBy(obj):
-registry.notify(ObjectCreatedEvent(object))
+registry.notify(ObjectCreatedEvent(obj))
 # set parent temporarily to avoid NotYet exceptions
-locate(object, self.context)
+locate(obj, self.context)
 # update object properties before adding it
-self.update_content(object, data)
+self.update_content(obj, data)
-self.add(object)
+self.add(obj)
-registry.notify(FormObjectCreatedEvent(object, self))
+registry.notify(FormObjectCreatedEvent(obj, self))
-return object
+return obj
 def update_content(self, content, data):
 changes = applyChanges(self, content, data.get(self, data))
 for subform in self.get_forms(include_self=False):
 if subform.mode == DISPLAY_MODE:
 continue
 subform_update = ICustomUpdateSubForm(subform, None)
 if subform_update is not None:
+# pylint: disable=assignment-from-no-return
 updates = subform_update.update_content(content, data.get(subform, data))
 if isinstance(updates, dict):
 changes.update(updates)
 else:
 changes.update(applyChanges(subform, content, data.get(subform, data)))
 class AddFormContextPermissionChecker(ContextRequestViewAdapter):
 """Add form context permission checker"""
 @property
 def edit_permission(self):
+"""Get permission associated with this form's context"""
 return self.view.edit_permission
 class AJAXAddForm(AddForm):
+# pylint: disable=abstract-method
 """AJAX add form"""
-def __call__(self):
+def __call__(self):  # pylint: disable=arguments-differ
 self.request.registry.notify(PageletCreatedEvent(self))
 data, errors = {}, ()
 for form in self.get_forms():
 form.check_mode()
 form.updateWidgets()
 try:
 widget = form.widgets[error.args[-1]]
 except KeyError:
 continue
 else:
-view = registry.getMultiAdapter((error, self.request, widget, widget.field, self, self.context),
+view = registry.getMultiAdapter(
-IErrorViewSnippet)
+(error, self.request, widget, widget.field, self, self.context),
+IErrorViewSnippet)
 view.update()
 widget.error = view
 errors = (view,)
 return self.get_ajax_errors(errors)
 # Fallback when you can't find widget
 for form in self.get_forms(include_self=False):
 try:
 form_output = form.get_ajax_output(changes)
 if form_output:
 for key, value in form_output.items():
-if isinstance(value, (list, tuple)) and (key in output):  # concatenate lists
+if isinstance(value, (list, tuple)) and (
+key in output):  # concatenate lists
 form_output[key] += output[key]
 output.update(form_output)
 except NotImplementedError:
 pass
 if output:
 return output
-else:
+return {
-return {
+'status': 'reload',
-'status': 'reload',
+'location': self.nextURL()
-'location': self.nextURL()
+}
-}
 @implementer(IDialog)
 class DialogAddForm(AddForm):
+# pylint: disable=abstract-method
 """Modal dialog add form"""
 buttons = Buttons(IModalAddFormButtons)
 dialog_class = 'modal-medium'
 @implementer(IInnerForm)
 class InnerAddForm(AddForm):
+# pylint: disable=abstract-method
 """Inner add form"""
 css_class = 'inner'
 buttons = Buttons(Interface)
 class AJAXEditForm(EditForm):
 """AJAX edit form"""
-def __call__(self):
+def __call__(self):  # pylint: disable=arguments-differ,too-many-branches
 # call form elements
 self.request.registry.notify(PageletCreatedEvent(self))
 data, errors = {}, ()
 for form in self.get_forms():
 form.check_mode()
 try:
 widget = form.widgets[error.args[-1]]
 except KeyError:
 continue
 else:
-view = registry.getMultiAdapter((error, self.request, widget, widget.field, self, self.context),
+view = registry.getMultiAdapter(
-IErrorViewSnippet)
+(error, self.request, widget, widget.field, self, self.context),
+IErrorViewSnippet)
 view.update()
 widget.error = view
 errors = (view,)
 return self.get_ajax_errors(errors)
 # Fallback when you can't find widget
 continue
 try:
 form_output = form.get_ajax_output(changes)
 if form_output:
 for key, value in form_output.items():
-if isinstance(value, (list, tuple)) and (key in output):  # concatenate lists
+if isinstance(value, (list, tuple)) and (
+key in output):  # concatenate lists
 form_output[key] += output[key]
 output.update(form_output)
 except NotImplementedError:
 pass
 return output
 # Form events subscribers
 #
 @subscriber(IFormCreatedEvent, context_selector=ISkinnable)
 def handle_form_skin(event):
+"""Apply skin on form's creation event"""
 request = _request = event.object.request
 if isinstance(request, PyramidPublisherRequest):
-_request = request._request
+_request = request._request  # pylint: disable=protected-access
-skin = ISkinnable(event.object).get_skin(_request)
+skin = ISkinnable(event.object).get_skin(_request)  # pylint: disable=assignment-from-no-return
 if skin is not None:
 apply_skin(request, skin)
-class FormSelector(object):
+class FormSelector:
 """Form event selector
 This selector can be used by subscriber to filter form events
 """
-def __init__(self, ifaces, config):
+def __init__(self, ifaces, config):  # pylint: disable=unused-argument
 if not isinstance(ifaces, (list, tuple)):
 ifaces = (ifaces,)
 self.interfaces = ifaces
 def text(self):
+"""Form's selector text"""
 return 'form_selector = %s' % str(self.interfaces)
 phash = text
 def __call__(self, event):
 if isinstance(event.form, intf):
 return True
 return False
-class WidgetSelector(object):
+class WidgetSelector:
 """Widget event selector
 This selector can be used by subscribers to filter widgets events
 """
-def __init__(self, ifaces, config):
+def __init__(self, ifaces, config):  # pylint: disable=unused-argument
 if not isinstance(ifaces, (list, tuple)):
 ifaces = (ifaces,)
 self.interfaces = ifaces
 def text(self):
+"""Widget's selector text"""
 return 'widget_selector = %s' % str(self.interfaces)
 phash = text
 def __call__(self, event):
 if isinstance(event.widget, intf):
 return True
 return False
-class ajax_config(object):
+class ajax_config:  # pylint: disable=invalid-name
 """Class decorator used to declare AJAX settings for a form.
-When decorating a form class, this decorator create a new subclass which will handle AJAX queries
+When decorating a form class, this decorator create a new subclass which will handle AJAX
-executed when submitting the form, and register this class as Pyramid's view.
+queries executed when submitting the form, and register this class as Pyramid's view.
 Decorator arguments (all optional) are:
-- **name**: AJAX view name
+- :param name: AJAX view name
-- **context** (or **for_**): view context type
+- :param context: (or **for_**): view context type
-- **layer** (or **request_type**): request type for which view is registered
+- :param layer: (or **request_type**): request type for which view is registered
-- **permission**: permission required to call the view; if not set, permission is extracted from form's
+- :param permission: permission required to call the view; if not set, permission is
-"edit_permission" attribute
+extracted from form's "edit_permission" attribute
-- **base**: base class for newly created AJAX form; if not set, inherits from :py:class:`AJAXEditForm`
+- :param base: base class for newly created AJAX form; if not set, inherits from
-- **implementer**: list of interfaces implemented by the new class
+:py:class:`AJAXEditForm`
-- **method** (or **request_method**): HTTP method name; if not defined, view is restricted to "POST" requests
+- :param implementer: list of interfaces implemented by the new class
-- **renderer**: name of Pyramid renderer used to return view output; defaults to 'json'
+- :param method: (or **request_method**): HTTP method name; if not defined, view is
-- **xhr**: Pyramid's view's "xhr" predicate; **True** by default
+restricted to "POST" requests
+- :param renderer: name of Pyramid renderer used to return view output; defaults to 'json'
+- :param xhr: Pyramid's view's "xhr" predicate; **True** by default
 """
 venusian = venusian  # for testing injection
 def __init__(self, **settings):
 def __call__(self, wrapped):
 settings = self.__dict__.copy()
 depth = settings.pop('_depth', 0)
-def callback(context, name, ob):
+def callback(context, name, obj):  # pylint: disable=unused-argument
 cdict = {
 '__name__': settings.get('name'),
-'__module__': ob.__module__,
+'__module__': obj.__module__,
-'permission': settings.get('permission') or ob.edit_permission
+'permission': settings.get('permission') or obj.edit_permission
 }
 # Set form's AJAX handler
-ob.ajax_handler = settings.get('name')
+obj.ajax_handler = settings.get('name')
 # Create new AJAX form and register view
 base = settings.pop('base')
-new_class = type('AJAX' + ob.__name__, (base, ob), cdict)
+new_class = type('AJAX' + obj.__name__, (base, obj), cdict)
 try:
 # check if current form is overriding "get_ajax_output" method
 if base not in (AJAXAddForm, AJAXEditForm):  # custom base
-ob_ajax_parent, _ = ob.get_ajax_output.__qualname__.split('.')
+ob_ajax_parent, _ = obj.get_ajax_output.__qualname__.split('.')
 base_ajax_parent, _ = base.get_ajax_output.__qualname__.split('.')
 if (ob_ajax_parent != base_ajax_parent) and \
 (ob_ajax_parent in ('AJAXForm', 'AJAXAddForm', 'AJAXEditForm')):
 new_class.get_ajax_output = base.get_ajax_output
 else:
-new_class.get_ajax_output = ob.get_ajax_output
+new_class.get_ajax_output = obj.get_ajax_output
 else:
-base_ajax_parent, _ = ob.get_ajax_output.__qualname__.split('.')
+base_ajax_parent, _ = obj.get_ajax_output.__qualname__.split('.')
-if base_ajax_parent not in ('AJAXForm', 'AJAXAddForm', 'AJAXEditForm'):  # overriden method
+if base_ajax_parent not in ('AJAXForm', 'AJAXAddForm', 'AJAXEditForm'):
-new_class.get_ajax_output = ob.get_ajax_output
+# overriden method
+new_class.get_ajax_output = obj.get_ajax_output
 except AttributeError:
 pass
 if 'implementer' in settings:
-implementer = settings.pop('implementer')
+impl = settings.pop('implementer')
-if not isinstance(implementer, (list, tuple, set)):
+if not isinstance(impl, (list, tuple, set)):
-implementer = (implementer,)
+impl = (impl,)
-classImplements(new_class, *implementer)
+classImplements(new_class, *impl)
-logger.debug('Registering AJAX view "{0}" for {1} ({2})'.format(settings.get('name'),
+LOGGER.debug('Registering AJAX view "{0}" for {1} ({2})'.format(
-str(settings.get('context', Interface)),
+settings.get('name'), str(settings.get('context', Interface)), str(new_class)))
-str(new_class)))
+config = context.config.with_package(info.module)  # pylint: disable=no-member
-config = context.config.with_package(info.module)
 config.add_view(view=new_class, **settings)
-info = self.venusian.attach(wrapped, callback, category='pyams_form',
+info = self.venusian.attach(wrapped, callback, category='pyams_form', depth=depth + 1)
-depth=depth + 1)
+if info.scope == 'class':  # pylint: disable=no-member
-if info.scope == 'class':
 # if the decorator was attached to a method in a class, or
 # otherwise executed at class scope, we need to set an
 # 'attr' into the settings if one isn't already in there
 if settings.get('attr') is None:
 settings['attr'] = wrapped.__name__
-settings['_info'] = info.codeinfo  # fbo "action_method"
+settings['_info'] = info.codeinfo  # pylint: disable=no-member
 return wrapped

changeset 204	c435de184bda
parent 195	e4b68da720e2
child 216	33bbf7a09d29