[Zope3-dev] setUpEditWidgets fails
Roger Ineichen
dev at projekt01.ch
Tue Mar 8 11:10:51 EST 2005
Hi Gary
From: Gary Poster [mailto:gary at modernsongs.com]
> Sent: Tuesday, March 08, 2005 5:02 PM
> To: dev at projekt01.ch
> Subject: Re: [Zope3-dev] setUpEditWidgets fails
>
>
> On Mar 8, 2005, at 10:19 AM, Roger Ineichen wrote:
>
> > Hi Gary
> >
> > Behalf Of Roger Ineichen
> >> Sent: Tuesday, March 08, 2005 4:05 PM
> >> To: zope3-dev at zope.org
> >> Subject: [Zope3-dev] setUpEditWidgets fails
> >>
> >> Hi Gary
> >>
> >> I have problems with our implementations using the method
> >> setUpEditWidgets().
> >>
> > btw
> > If I comment out the the method canWrite in
> > zope\app\form\utility.py like:
> > ----------
> > #authorized = security.canWrite(source, name)
> > ----------
> >
> > and set the authorized method to:
> > ----------
> > authorized = True
> > ----------
> >
> > It seems that I can edit the instance.
> >
> > This means that I have wirte permission on the fields.
> > Or not? If so, why does the canWrite() method fail?
>
> Hm. What is the name that fails? You may not be changing
> the field to
> which you do not have access...or maybe there is a problem
> somewhere.
> Were you able to use either of the diagnostic tools I suggested?
>
> Gary
Thanks for the script, I try it and send you a note if it's working.
Right now I use a general script for dump python objects.
---------------------------------------------------------------------
def dumpObj(obj, maxlen=77, lindent=24, maxspew=600):
"""Print a nicely formatted overview of an object.
The output lines will be wrapped at maxlen, with lindent of space
for names of attributes. A maximum of maxspew characters will be
printed for each attribute value.
You can hand dumpObj any data type -- a module, class, instance,
new class.
Note that in reformatting for compactness the routine trashes any
formatting in the docstrings it prints.
Example:
>>> class Foo(object):
a = 30
def bar(self, b):
"A silly method"
return a*b
... ... ... ...
>>> foo = Foo()
>>> dumpObj(foo)
Instance of class 'Foo' as defined in module __main__ with id
136863308
Documentation string: None
Built-in Methods: __delattr__, __getattribute__, __hash__,
__init__
__new__, __reduce__, __repr__, __setattr__,
__str__
Methods:
bar "A silly method"
Attributes:
__dict__ {}
__weakref__ None
a 30
"""
import types
# Formatting parameters.
ltab = 2 # initial tab in front of level 2 text
# There seem to be a couple of other types; gather templates of them
MethodWrapperType = type(object().__hash__)
#
# Gather all the attributes of the object
#
objclass = None
objdoc = None
objmodule = '<None defined>'
methods = []
builtins = []
classes = []
attrs = []
for slot in dir(obj):
attr = getattr(obj, slot)
if slot == '__class__':
objclass = attr.__name__
elif slot == '__doc__':
objdoc = attr
elif slot == '__module__':
objmodule = attr
elif (isinstance(attr, types.BuiltinMethodType) or
isinstance(attr, MethodWrapperType)):
builtins.append( slot )
elif (isinstance(attr, types.MethodType) or
isinstance(attr, types.FunctionType)):
methods.append( (slot, attr) )
elif isinstance(attr, types.TypeType):
classes.append( (slot, attr) )
else:
attrs.append( (slot, attr) )
#
# Organize them
#
methods.sort()
builtins.sort()
classes.sort()
attrs.sort()
#
# Print a readable summary of those attributes
#
normalwidths = [lindent, maxlen - lindent]
tabbedwidths = [ltab, lindent-ltab, maxlen - lindent - ltab]
def truncstring(s, maxlen):
if len(s) > maxlen:
return s[0:maxlen] + ' ...(%d more chars)...' % (len(s) -
maxlen)
else:
return s
# Summary of introspection attributes
if objclass == '':
objclass = type(obj).__name__
intro = "Instance of class '%s' as defined in module %s with id %d" % \
(objclass, objmodule, id(obj))
print '\n'.join(prettyPrint(intro, maxlen))
# Object's Docstring
if objdoc is None:
objdoc = str(objdoc)
else:
objdoc = ('"""' + objdoc.strip() + '"""')
print
print prettyPrintCols( ('Documentation string:',
truncstring(objdoc, maxspew)),
normalwidths, ' ')
# Built-in methods
if builtins:
bi_str = delchars(str(builtins), "[']") or str(None)
print
print prettyPrintCols( ('Built-in Methods:',
truncstring(bi_str, maxspew)),
normalwidths, ', ')
# Classes
if classes:
print
print 'Classes:'
for (classname, classtype) in classes:
classdoc = getattr(classtype, '__doc__', None) or '<No
documentation>'
print prettyPrintCols( ('',
classname,
truncstring(classdoc, maxspew)),
tabbedwidths, ' ')
# User methods
if methods:
print
print 'Methods:'
for (methodname, method) in methods:
methoddoc = getattr(method, '__doc__', None) or '<No documentation>'
print prettyPrintCols( ('',
methodname,
truncstring(methoddoc, maxspew)),
tabbedwidths, ' ')
# Attributes
if attrs:
print
print 'Attributes:'
for (attr, val) in attrs:
print prettyPrintCols( ('',
attr,
truncstring(str(val), maxspew)),
tabbedwidths, ' ')
def prettyPrintCols(strings, widths, split=' '):
"""Pretty prints text in colums, with each string breaking at
split according to prettyPrint. margins gives the corresponding
right breaking point."""
assert len(strings) == len(widths)
strings = map(nukenewlines, strings)
# pretty print each column
cols = [''] * len(strings)
for i in range(len(strings)):
cols[i] = prettyPrint(strings[i], widths[i], split)
# prepare a format line
format = ''.join(["%%-%ds" % width for width in widths[0:-1]]) + "%s"
def formatline(*cols):
return format % tuple(map(lambda s: (s or ''), cols))
# generate the formatted text
return '\n'.join(map(formatline, *cols))
def prettyPrint(string, maxlen=75, split=' '):
"""Pretty prints the given string to break at an occurrence of
split where necessary to avoid lines longer than maxlen.
This will overflow the line if no convenient occurrence of split
is found"""
# Tack on the splitting character to guarantee a final match
string += split
lines = []
oldeol = 0
eol = 0
while not (eol == -1 or eol == len(string)-1):
eol = string.rfind(split, oldeol, oldeol+maxlen+len(split))
lines.append(string[oldeol:eol])
oldeol = eol + len(split)
return lines
def nukenewlines(string):
"""Strip newlines and any trailing/following whitespace; rejoin
with a single space where the newlines were.
Bug: This routine will completely butcher any whitespace-formatted
text."""
if not string: return ''
lines = string.splitlines()
return ' '.join( [line.strip() for line in lines] )
def delchars(str, chars):
"""Returns a string for which all occurrences of characters in
chars have been removed."""
# Translate demands a mapping string of 256 characters;
# whip up a string that will leave all characters unmolested.
identity = ''.join([chr(x) for x in range(256)])
return str.translate(identity, chars)
---------------------------------------------------------------------
Regards
Roger Ineichen
>
More information about the Zope3-dev
mailing list