def widget(self):
"""Returns the associated widget if defined. If there is none defined, returns None."""
args = ()
kwargs = {}
if self.column_name is None:
if self.position not in self.table.column_widgets:
return None
wcls = self.table.column_widgets[self.position]
else:
if self.column_name not in self.table.column_widgets:
return None
wcls = self.table.column_widgets[self.column_name]
# Verpick, ...
if isinstance(wcls, ConstructorResolvable):
return wcls.resolve(self)
# We cannot use WidgetDescriptor's facility for instantiation as it does caching and all
# that stuff
if isinstance(wcls, WidgetDescriptor):
args = wcls.args
kwargs = wcls.kwargs
wcls = wcls.klass
kwargs = copy(kwargs)
if 'logger' not in kwargs:
kwargs['logger'] = create_child_logger(self.logger, wcls.__name__)
return wcls(self, *args, **kwargs)
def __get__(self, obj, type=None):
if obj is None: # class access
return self
# Cache on WidgetDescriptor
if self not in obj._widget_cache:
kwargs = copy(self.kwargs)
try:
kwargs['logger'] = create_child_logger(
obj.logger, obj._desc_name_mapping[self])
except KeyError:
kwargs['logger'] = obj.logger
except AttributeError:
pass
args, kwargs = process_parameters(obj, self.args, kwargs)
if issubclass(self.klass, ParametrizedView):
# Shortcut, don't cache as the ParametrizedViewRequest is not the widget yet
return ParametrizedViewRequest(obj, self.klass, *args,
**kwargs)
else:
o = self.klass(obj, *args, **kwargs)
o.parent_descriptor = self
obj._widget_cache[self] = o
widget = obj._widget_cache[self]
obj.child_widget_accessed(widget)
return widget
def __call__(self, *args, **kwargs):
if len(args) > len(self.view_class.PARAMETERS):
raise TypeError(
'You passed more parameters than {} accepts'.format(
self.view_class.__name__))
param_dict = {}
for passed_arg, required_arg in zip(args, self.view_class.PARAMETERS):
param_dict[required_arg] = passed_arg
for key, value in kwargs.items():
if key not in self.view_class.PARAMETERS:
raise TypeError('Unknown view parameter {}'.format(key))
param_dict[key] = value
for param in self.view_class.PARAMETERS:
if param not in param_dict:
raise TypeError(
'You did not pass the required parameter {} into {}'.
format(param, self.view_class.__name__))
new_kwargs = copy(self.kwargs)
if 'additional_context' not in self.kwargs:
new_kwargs['additional_context'] = {}
new_kwargs['additional_context'].update(param_dict)
# And finally, set up a nice logger
parent_logger = self.parent_object.logger
current_name = self.view_class.__name__
# Now add the params to the name so it is class_name(args)
current_name += call_sig(
(), param_dict) # no args because we process everything into dict
new_kwargs['logger'] = create_child_logger(parent_logger, current_name)
result = self.view_class(self.parent_object, *self.args, **new_kwargs)
self.parent_object.child_widget_accessed(result)
return result
def __init__(self, parent, logger=None):
self.parent = parent
if logger is None:
self.logger = create_child_logger(parent.logger, type(self).__name__)
elif isinstance(logger, PrependParentsAdapter):
# The logger is already prepared
self.logger = logger
else:
# We need a PrependParentsAdapter here.
self.logger = create_widget_logger(type(self).__name__, logger)
self.extra = ExtraData(self)
self._widget_cache = {}
self._initialized_included_widgets = {}
