rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def __setitem__(self, name, field): assert name == field.getName() self.addField(field) |
deprecated( "Adding '%s' with property '%s' set " "to %s but '%s' has the same value. Re-using the property " "above on different named fields is not allowed anymore." % | raise SchemaException( "Tried to add '%s' with property '%s' set " "to %s but '%s' has the same value." % | def _validateOnAdd(self, field): """Validates fields on adding and bootstrapping """ # interface test if not IField.isImplementedBy(field): raise ValueError, "Object doesn't implement IField: %r" % field name = field.getName() # two primary fields are forbidden if getattr(field, 'primary', False): res = self.hasPrimary... |
security.declareProtected(CMFCorePermissions.View, 'get') | security.declareProtected(permissions.View, 'get') | def __getitem__(self, name): return self._fields[name] |
security.declareProtected(CMFCorePermissions.View, 'has_key') | security.declareProtected(permissions.View, 'has_key') | def get(self, name, default=None): return self._fields.get(name, default) |
security.declareProtected(CMFCorePermissions.View, 'keys') | security.declareProtected(permissions.View, 'keys') | def has_key(self, name): return self._fields.has_key(name) |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def keys(self): return self._names |
security.declareProtected(CMFCorePermissions.View, 'searchable') | security.declareProtected(permissions.View, 'searchable') | def keys(self): return self._names |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def __init__(self): DefaultLayerContainer.__init__(self) #Layer init work marshall = self._props.get('marshall') if marshall: self.registerLayer('marshall', marshall) |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def initializeLayers(self, instance, item=None, container=None): # scan each field looking for registered layers optionally # call its initializeInstance method and then the # initializeField method initializedLayers = [] called = lambda x: x in initializedLayers |
security.declareProtected(CMFCorePermissions.View, 'copy') | security.declareProtected(permissions.View, 'copy') | def __add__(self, other): c = SchemaLayerContainer() layers = {} for k, v in self.registeredLayers(): layers[k] = v for k, v in other.registeredLayers(): layers[k] = v for k, v in layers.items(): c.registerLayer(k, v) return c |
security.declareProtected(CMFCorePermissions.View, 'copy') | security.declareProtected(permissions.View, 'copy') | def __add__(self, other): c = BasicSchema() # We can't use update and keep the order so we do it manually for field in self.fields(): c.addField(field) for field in other.fields(): c.addField(field) # Need to be smarter when joining layers # and internal props c._props.update(self._props) return c |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, 'edit') | security.declareProtected(permissions.ModifyPortalContent, 'edit') | def copy(self): """Returns a deep copy of this Schema. """ c = BasicSchema() for field in self.fields(): c.addField(field.copy()) # Need to be smarter when joining layers # and internal props c._props.update(self._props) return c |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def edit(self, instance, name, value): if self.allow(name): instance[name] = value |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def setDefaults(self, instance): """Only call during object initialization. Sets fields to schema defaults """ ## XXX think about layout/vs dyn defaults for field in self.values(): if field.getName().lower() == 'id': continue if field.type == "reference": continue |
security.declareProtected(CMFCorePermissions.View, 'allow') | security.declareProtected(permissions.View, 'allow') | def updateAll(self, instance, **kwargs): """This method mutates fields in the given instance. |
security.declareProtected(CMFCorePermissions.View, 'validate') | security.declareProtected(permissions.View, 'validate') | def allow(self, name): return self.has_key(name) |
security.declareProtected(CMFCorePermissions.View, | security.declareProtected(permissions.View, | def validate(self, instance=None, REQUEST=None, errors=None, data=None, metadata=None): """Validate the state of the entire object. |
security.declareProtected(CMFCorePermissions.View, | security.declareProtected(permissions.View, | def toString(self): s = '%s: {' % self.__class__.__name__ for f in self.fields(): s = s + '%s,' % (f.toString()) s = s + '}' return s |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def signature(self): from md5 import md5 return md5(self.toString()).digest() |
security.declareProtected(CMFCorePermissions.View, 'getSchemataNames') | security.declareProtected(permissions.View, 'getSchemataNames') | def changeSchemataForField(self, fieldname, schemataname): """ change the schemata for a field """ field = self[fieldname] self.delField(fieldname) field.schemata = schemataname self.addField(field) |
security.declareProtected(CMFCorePermissions.View, 'getSchemataFields') | security.declareProtected(permissions.View, 'getSchemataFields') | def getSchemataNames(self): """Return list of schemata names in order of appearing""" lst = [] for f in self.fields(): if not f.schemata in lst: lst.append(f.schemata) return lst |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def getSchemataFields(self, name): """Return list of fields belong to schema 'name' in order of appearing """ return [f for f in self.fields() if f.schemata == name] |
security.declareProtected(CMFCorePermissions.View, 'copy') | security.declareProtected(permissions.View, 'copy') | def __add__(self, other): c = Schema() # We can't use update and keep the order so we do it manually for field in self.fields(): c.addField(field) for field in other.fields(): c.addField(field) # Need to be smarter when joining layers # and internal props c._props.update(self._props) layers = {} for k, v in self.regist... |
security.declareProtected(CMFCorePermissions.View, 'wrapped') | security.declareProtected(permissions.View, 'wrapped') | def copy(self, factory=None): """Returns a deep copy of this Schema. """ if factory is None: factory = self.__class__ c = factory() for field in self.fields(): c.addField(field.copy()) # Need to be smarter when joining layers # and internal props c._props.update(self._props) layers = {} for k, v in self.registeredLayer... |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def wrapped(self, parent): schema = self.copy(factory=WrappedSchema) return schema.__of__(parent) |
>>> from Products.Archetypes.public import StringField as SF | >>> from Products.Archetypes.atapi import StringField as SF | def moveField(self, name, direction=None, pos=None, after=None, before=None): """Move a field |
>>> safter.moveField('a', before='b') | >>> safter.moveField('a', after='b') | def moveField(self, name, direction=None, pos=None, after=None, before=None): """Move a field |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def _moveFieldInSchemata(self, name, direction): """Moves a field with the name 'name' inside its schemata """ if not direction in (-1, 1): raise ValueError, "Direction must be either -1 or 1" |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def delSchemata(self, name): """Remove all fields belonging to schemata 'name'""" for f in self.fields(): if f.schemata == name: self.delField(f.getName()) |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def addSchemata(self, name): """Create a new schema by adding a new field with schemata 'name' """ from Products.Archetypes.Field import StringField |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def moveSchemata(self, name, direction): """Move a schemata to left (direction=-1) or to right (direction=1) """ if not direction in (-1, 1): raise ValueError, 'Direction must be either -1 or 1' |
ExtensibleMetadata.__init__(self) | def __init__(self, oid, **kwargs): # Call skinned first cause baseobject will set new defaults on # those attributes anyway SkinnedFolder.__init__(self, oid, self.Title()) BaseObject.__init__(self, oid, **kwargs) ExtensibleMetadata.__init__(self) | |
def Description(self, **kwargs): """we have to override Description here to handle arbitrary arguments since PortalFolder defines it. """ self.getField('description').get(self, **kwargs) | def Description(self, **kwargs): """we have to override Description here to handle arbitrary arguments since PortalFolder defines it. """ self.getField('description').get(self, **kwargs) | |
sys.exc_info()) | '\n'.join(traceback.format_exception(*sys.exc_info()))) | def getObject(self, REQUEST=None): """ Used to resolve UIDs into real objects. This also must be annotation aware. The protocol is: We have the path to an object. We get this object. If its UID is not the UID in the brains then we need to pull it from the reference annotation and return that object |
if isinstance(title, unicode): return title.encode('utf-8') | def Title(self): # TODO: dumb try to make sure UID catalog doesn't fail if Title can't be # converted to an ascii string # Title is used for sorting only, maybe we could replace it by a better # version title = self._obj.Title() if isinstance(title, unicode): return title.encode('utf-8') try: return str(title) except U... | |
d, f, mimetype = mtr(body[:8096], **kw) | try: d, f, mimetype = mtr(body[:8096], **kw) except UnicodeDecodeError: d, f, mimetype = mtr(len(body) < 8096 and body or '', **kw) | def _process_input(self, value, file=None, default=None, mimetype=None, instance=None, filename='', **kwargs): if file is None: file = self._make_file(self.getName(), title='', file='', instance=instance) if IBaseUnit.isImplementedBy(value): mimetype = value.getContentType() or mimetype filename = value.getFilename() o... |
if not str(msg).endswith('exists'): | if not str(msg).find('exists') > 0: | def initalizeInstance(self, instance): c_tool = getToolByName(instance, TOOL_NAME) connection_id = c_tool.getConnFor(instance) fields = instance.Schema().fields() fields = [f for f in fields if IObjectField.isImplementedBy(f) \ and ISQLStorage.isImplementedBy(f.getStorage())] columns = [] args = {} for field in fields:... |
db_type_map = {} | db_type_map = { 'object': 'text', 'fixedpoint': 'float', 'reference': 'varchar', 'datetime': 'datetime', } | def cleanupField(self, instance, field): pass |
image.filename = value.filename | image.filename = hasattr(value, 'filename') and value.filename or '' | def set(self, instance, value, **kwargs): # do we have to delete the image? if value=="DELETE_IMAGE": ObjectField.set(self, instance, None, **kwargs) return |
setattr(self, config.UUID_ATTR, None) | if not hasattr(self,config.UUID_ATTR) or len(uc(UID=self.UID())): setattr(self, config.UUID_ATTR, None) | def manage_afterClone(self, item): """ Get a new UID (effectivly dropping reference) (Called when the object is cloned.) """ uc = getToolByName(self, config.UID_CATALOG) |
test.failUnlessEqual(str(obj.effective_date), str(DateTime(time, 0))) | def compareMetadataOf(test, obj, data='default', mimetype='application/octet-stream', time=1000): l_data = (data,) test.failUnless(obj.Title() == data, 'Title') test.failUnless(obj.Subject() == l_data, 'Subject: %s, %s' % (obj.Subject(), l_data)) test.failUnless(obj.Description() == data, 'Description') test.failUnless... | |
test.failUnlessEqual(str(obj.effective_date), str(DateTime(time, 0))) test.failUnlessEqual(str(obj.expiration_date), str(DateTime(time, 0))) | if aq_base(obj) is obj: test.failUnless(isinstance(obj.effective_date, ComputedAttribute)) test.failUnless(isinstance(obj.expiration_date, ComputedAttribute)) else: test.failUnlessEqual(str(obj.effective_date), str(DateTime(time, 0))) test.failUnlessEqual(str(obj.expiration_date), str(DateTime(time, 0))) | def compareMetadataOf(test, obj, data='default', mimetype='application/octet-stream', time=1000): l_data = (data,) test.failUnless(obj.Title() == data, 'Title') test.failUnless(obj.Subject() == l_data, 'Subject: %s, %s' % (obj.Subject(), l_data)) test.failUnless(obj.Description() == data, 'Description') test.failUnless... |
try: res = service.translate(domain, msgid, mapping=mapping, context=context, target_language=target_language, default=default) except TypeError: res = service.translate(domain, msgid, mapping=mapping, context=context, target_language=target_language) | if hasattr(service, 'utranslate'): res = service.utranslate(domain, msgid, mapping=mapping, context=context, target_language=target_language, default=default) else: res = service.translate(domain, msgid, mapping=mapping, context=context, target_language=target_language, default=default) | def translate_wrapper(domain, msgid, mapping=None, context=None, target_language=None, default=None): # wrapper for calling the translate() method with a fallback value try: res = service.translate(domain, msgid, mapping=mapping, context=context, target_language=target_language, default=default) except TypeError: #Loc... |
self.failUnless(field.default == []) | self.failUnless(field.default == ()) | def test_subject(self): dummy = self._dummy field = dummy.getField('subject') |
self.failUnless(field.default == []) | self.failUnless(field.default == ()) | def test_contributors(self): dummy = self._dummy field = dummy.getField('contributors') |
log("Warning: no Python Imaging Libraries (PIL) found. Imagefield can't scale.") | log("Warning: no Python Imaging Libraries (PIL) found."+\ "Archetypes based ImageField's don't scale if neccessary.") | def set(self, instance, value, **kwargs): obj = self.get(instance, **kwargs) value = self._process_input(value, default=self.default, \ **kwargs) if value is None or value == '': # do nothing return |
if self.sizes: | if self.sizes and has_pil: | def set(self, instance, value, **kwargs): # Do we have to delete the image? if value=="DELETE_IMAGE": if self.sizes: # unset different sizes for n, size in self.sizes.items(): id = self.getName() + "_" + n self.storage.unset(id, instance, **kwargs) # unset main field too ObjectField.unset(self, instance, **kwargs) retu... |
self.storage.unset(id, instance, **kwargs) | try: self.storage.unset(id, instance, **kwargs) except KeyError: pass | def set(self, instance, value, **kwargs): # Do we have to delete the image? if value=="DELETE_IMAGE": if self.sizes: # unset different sizes for n, size in self.sizes.items(): id = self.getName() + "_" + n self.storage.unset(id, instance, **kwargs) # unset main field too ObjectField.unset(self, instance, **kwargs) retu... |
sID, sobj = self._uidFor(object) objects = self._resolveBrains(self._queryFor(sid=sID, relationship=relationship)) if objects: [self._deleteReference(b) for b in objects] | [self._deleteReference(b) for b in (self.getReferences(object) or []) + (self.getBackReferences(object) or [])] | def deleteReferences(self, object, relationship=None): """delete all the references held by an object""" sID, sobj = self._uidFor(object) objects = self._resolveBrains(self._queryFor(sid=sID, relationship=relationship)) if objects: [self._deleteReference(b) for b in objects] |
class DummyTool: | class DummyTool(ReferenceEngine): | def gen_dummy(storage_class): Dummy.schema = Schema(( ObjectField('aobjectfield', storage = storage_class(), widget = StringWidget(label = 'aobjectfield', description = 'Just a object field for the testing')), TextField('atextfield', storage = storage_class(), widget = StringWidget(label = 'atextfield', description = ... |
"""add a dictionnary of objects to session variable | """add a dictionary of objects to the session | def addSubObjects(self, objects, REQUEST=None): """add a dictionnary of objects to session variable """ if objects: if REQUEST is None: REQUEST = self.REQUEST key = '/'.join(self.getPhysicalPath()) session = REQUEST.SESSION defined = session.get(key, {}) defined.update(objects) session[key] = defined |
"""add a dictionnary of objects to session variable | """Get a dictionary of objects from the session | def getSubObject(self, name, REQUEST, RESPONSE=None): """add a dictionnary of objects to session variable """ try: data = REQUEST.SESSION[self.absolute_url()][name] except AttributeError: return except KeyError: return mtr = self.mimetypes_registry mt = mtr.classify(data, filename=name) return Wrapper(data, name, mt or... |
return self.getAccessor(instance)(**kwargs) | accessor = self.getAccessor(instance) if accessor is None: return self.get(instance, **kwargs) return accessor(**kwargs) | def getRaw(self, instance, **kwargs): return self.getAccessor(instance)(**kwargs) |
field.vocabulary = DisplayList([('', '<any>')]) + \ | field.vocabulary = DisplayList([('', '<any>', 'at_search_any')]) + \ | def getWidgets(self, instance=None, package=None, type=None, context=None, mode='edit', fields=None, schemata=None, nosort=None): """Empty widgets for standalone rendering""" |
instantiate the widget if a class was given | COMMENT TODO - what does this do? | def _widgetLayer(self): """ instantiate the widget if a class was given """ if hasattr(self, 'widget') and type(self.widget) == ClassType: self.widget = self.widget() |
if getattr(sp, 'ext_editor', None) \ and self.checkPermission(mode='edit', instance=instance): | if getattr(sp, 'ext_editor', None) and self.checkPermission(mode='edit', instance=instance): | def checkExternalEditor(self, instance): """ Checks if the user may edit this field and if external editor is enabled on this instance """ |
def getStorageType(self): """Return the type of the storage of this field as a string""" return className(self.storage) | def getStorageName(self): """Return the storage name that is configured for this field as a string""" return self.storage.getName() | |
security.declarePublic('getType') def getType(self): """Return the type of this field as a string""" return className(self) | def getName(self): """Return the name of this field as a string""" return self.__name__ | |
def get(self, instance, **kwargs): value = ObjectField.get(self, instance, **kwargs) return encode(value, instance, **kwargs) def set(self, instance, value, **kwargs): kwargs['field'] = self value = decode(aq_base(value), instance, **kwargs) self.storage.set(self.getName(), instance, value, **kwargs) | class MetadataField(ObjectField): """Metadata fields have special storage and explictly no markup as requirements. """ __implements__ = ObjectField.__implements__ _properties = Field._properties.copy() _properties.update({ 'type' : 'metadata', 'isMetadata' : 1, 'generateMode' : 'mVc', 'mode' : 'rw', 'storage' : Metada... | def get(self, instance, **kwargs): value = ObjectField.get(self, instance, **kwargs) return encode(value, instance, **kwargs) |
'widget' : FileWidget, | def set(self, instance, value, **kwargs): kwargs['field'] = self # Remove acquisition wrappers value = decode(aq_base(value), instance, **kwargs) self.storage.set(self.getName(), instance, value, **kwargs) | |
default=self.default, | default=self.default, \ | def set(self, instance, value, **kwargs): """ Assign input value to object. If mimetype is not specified, pass to processing method without one and add mimetype returned to kwargs. Assign kwargs to instance. """ if not kwargs.has_key('mimetype'): kwargs['mimetype'] = None |
def _process_input(self, value, default=None, **kwargs): | def _process_input(self, value, default=None, mimetype=None, encoding=None, **kwargs): | def _process_input(self, value, default=None, **kwargs): # We also need to handle the case where there is a baseUnit # for this field containing a valid set of data that would # not be reuploaded in a subsequent edit, this is basically # migrated from the old BaseObject.set method if ((isinstance(value, FileUpload) and... |
if ((isinstance(value, FileUpload) and value.filename != '') or (isinstance(value, FileType) and value.name != '')): if not value.read(1): return default value.seek(0) return value if IBaseUnit.isImplementedBy(value): return value | def _process_input(self, value, default=None, **kwargs): # We also need to handle the case where there is a baseUnit # for this field containing a valid set of data that would # not be reuploaded in a subsequent edit, this is basically # migrated from the old BaseObject.set method if ((isinstance(value, FileUpload) and... | |
return value raise TextFieldException(('Value is not File, String or ' 'BaseUnit on %s: %r' % (self.getName(), type(value)))) | if encoding is not None and type(value) == type(u''): value = value.encode(encoding) else: value = str(value) if mimetype is None: mimetype, enc = guess_content_type('', value, mimetype) if not value: return default, mimetype return value, mimetype else: if ((isinstance(value, FileUpload) and value.filename != '') or (... | def _process_input(self, value, default=None, **kwargs): # We also need to handle the case where there is a baseUnit # for this field containing a valid set of data that would # not be reuploaded in a subsequent edit, this is basically # migrated from the old BaseObject.set method if ((isinstance(value, FileUpload) and... |
value = self.getRaw(instance, raw=1) if IBaseUnit.isImplementedBy(value): return str(value.getContentType()) | accessor = self.getEditAccessor(instance) if accessor is not None: value = accessor(maybe_baseunit=1) | def getContentType(self, instance): """Return the mime type of object if known or can be guessed; otherwise, return None.""" value = '' value = self.getRaw(instance, raw=1) if IBaseUnit.isImplementedBy(value): return str(value.getContentType()) mimetype = getattr(aq_base(value), 'mimetype', None) if mimetype is None: m... |
else: mimetype = str(mimetype) | def getContentType(self, instance): """Return the mime type of object if known or can be guessed; otherwise, return None.""" value = '' value = self.getRaw(instance, raw=1) if IBaseUnit.isImplementedBy(value): return str(value.getContentType()) mimetype = getattr(aq_base(value), 'mimetype', None) if mimetype is None: m... | |
def getRaw(self, instance, raw=0, **kwargs): """ if raw, return the base unit object, else return encoded raw data """ value = self.get(instance, raw=1, **kwargs) if raw or not IBaseUnit.isImplementedBy(value): return value try: return value.getRaw(encoding=kwargs.get('encoding'), instance=instance) except TypeError: ... | def getRaw(self, instance, **kwargs): """Return raw data of object.""" kwargs['raw'] = 1 value = self.get(instance, **kwargs) if not kwargs.get('maybe_baseunit', 0) and IBaseUnit.isImplementedBy(value): return value.getRaw() return value | def getRaw(self, instance, raw=0, **kwargs): """ if raw, return the base unit object, else return encoded raw data """ value = self.get(instance, raw=1, **kwargs) if raw or not IBaseUnit.isImplementedBy(value): return value try: return value.getRaw(encoding=kwargs.get('encoding'), instance=instance) except TypeError: #... |
""" If raw, return the base unit object, else return value of object transformed into requested mime type. | """ Return value of object, transformed into requested mime type. | def get(self, instance, mimetype=None, raw=0, **kwargs): """ If raw, return the base unit object, else return value of object transformed into requested mime type. |
return encode(value, instance, **kwargs) | return value | def get(self, instance, mimetype=None, raw=0, **kwargs): """ If raw, return the base unit object, else return value of object transformed into requested mime type. |
return data or '' | if not data: return '' return data | def get(self, instance, mimetype=None, raw=0, **kwargs): """ If raw, return the base unit object, else return value of object transformed into requested mime type. |
value = self._process_input(value, default=self.default, **kwargs) encoding = kwargs.get('encoding') if type(value) is type(u'') and encoding is None: encoding = 'UTF-8' if not IBaseUnit.isImplementedBy(value): value = BaseUnit(self.getName(), value, instance=instance, encoding=encoding, mimetype=kwargs.get('mimetype'... | if not kwargs.has_key('mimetype'): kwargs['mimetype'] = None try: encoding = kwargs.get('encoding') or \ instance.portal_properties.site_properties.getProperty('default_charset') except AttributeError: import site encoding = site.encoding kwargs['encoding'] = encoding value, mimetype = self._process_input(value, defau... | def set(self, instance, value, **kwargs): """ Assign input value to object. If mimetype is not specified, pass to processing method without one and add mimetype returned to kwargs. Assign kwargs to instance. """ value = self._process_input(value, default=self.default, **kwargs) encoding = kwargs.get('encoding') if type... |
if type(value) in STRING_TYPES: | if type(value) == type(''): | def set(self, instance, value, **kwargs): """ If passed-in value is a string, split at line breaks and remove leading and trailing white space before storing in object with rest of properties. """ __traceback_info__ = value, type(value) if type(value) in STRING_TYPES: value = value.split('\n') value = [decode(v.strip(... |
value = [decode(v.strip(), instance, **kwargs) for v in value if v.strip()] | value = [v.strip() for v in value if v.strip()] | def set(self, instance, value, **kwargs): """ If passed-in value is a string, split at line breaks and remove leading and trailing white space before storing in object with rest of properties. """ __traceback_info__ = value, type(value) if type(value) in STRING_TYPES: value = value.split('\n') value = [decode(v.strip(... |
def get(self, instance, **kwargs): value = ObjectField.get(self, instance, **kwargs) return [encode(v, instance, **kwargs) for v in value] | def set(self, instance, value, **kwargs): """ If passed-in value is a string, split at line breaks and remove leading and trailing white space before storing in object with rest of properties. """ __traceback_info__ = value, type(value) if type(value) in STRING_TYPES: value = value.split('\n') value = [decode(v.strip(... | |
__traceback_info__ = (instance, self.getName(), value) | def set(self, instance, value, **kwargs): """ Add one or more passed in references to the object. Before setting the value the reference gets also be established in the reference tool """ | |
newValue = [] | def set(self, instance, value, **kwargs): """ Add one or more passed in references to the object. Before setting the value the reference gets also be established in the reference tool """ | |
instance.addReference(target, refname) newValue.append(uid) | instance.addReference(target,refname) | def set(self, instance, value, **kwargs): """ Add one or more passed in references to the object. Before setting the value the reference gets also be established in the reference tool """ |
instance.addReference(target, refname) newValue = value ObjectField.set(self, instance, newValue, **kwargs) | instance.addReference(target,refname) ObjectField.set(self, instance, value, **kwargs) | def set(self, instance, value, **kwargs): """ Add one or more passed in references to the object. Before setting the value the reference gets also be established in the reference tool """ |
catalog = getToolByName(content_instance, config.UID_CATALOG) | catalog = getToolByName(content_instance, 'portal_catalog') | def Vocabulary(self, content_instance=None): # If we have a method providing the list of types go with it, # it can always pull allowed_types if it needs to (not that we # pass the field name) value = ObjectField.Vocabulary(self, content_instance) if value: return value results = [] if self.allowed_types: catalog = get... |
'image_class': Image, | def isBinary(self): return 1 | |
image = self.image_class(self.getName(), self.getName(), value, mimetype) | image = Image(self.getName(), self.getName(), value, mimetype) | def set(self, instance, value, **kwargs): # Do we have to delete the image? if value=="DELETE_IMAGE": ObjectField.set(self, instance, None, **kwargs) return |
if image.width > self.max_size[0] or \ image.height > self.max_size[1]: | if image.width > self.max_size[0] or image.height > self.max_size[1]: | def set(self, instance, value, **kwargs): # Do we have to delete the image? if value=="DELETE_IMAGE": ObjectField.set(self, instance, None, **kwargs) return |
imgdata = self.scale(data,w,h) image = self.image_class(self.getName(), self.getName(), imgdata, mimetype) | if w and h: imgdata = self.scale(data,w,h) image = Image(self.getName(), self.getName(), imgdata, mimetype) | def set(self, instance, value, **kwargs): # Do we have to delete the image? if value=="DELETE_IMAGE": ObjectField.set(self, instance, None, **kwargs) return |
image2 = self.image_class(id, self.getName(), imgdata, 'image/jpeg') | image2 = Image(id, self.getName(), imgdata, 'image/jpeg') | def set(self, instance, value, **kwargs): # Do we have to delete the image? if value=="DELETE_IMAGE": ObjectField.set(self, instance, None, **kwargs) return |
pilfilter = 0 if PIL.Image.VERSION >= "1.1.3": pilfilter = 1 | def scale(self,data,w,h): """ scale image (with material from ImageTag_Hotfix)""" #make sure we have valid int's keys = {'height':int(h), 'width':int(w)} | |
image.thumbnail((keys['width'],keys['height']), pilfilter) | image.thumbnail((keys['width'],keys['height'])) | def scale(self,data,w,h): """ scale image (with material from ImageTag_Hotfix)""" #make sure we have valid int's keys = {'height':int(h), 'width':int(w)} |
image.save(thumbnail_file, "JPEG", quality=88) | image.save(thumbnail_file, "JPEG") | def scale(self,data,w,h): """ scale image (with material from ImageTag_Hotfix)""" #make sure we have valid int's keys = {'height':int(h), 'width':int(w)} |
def getContentType(self, instance): img = self.getRaw(instance) if img: return img.getContentType() return '' | def getContentType(self, instance): img = self.getRaw(instance) if img: return img.getContentType() return '' | |
from cgi import escape from cStringIO import StringIO import sys from zLOG import LOG, ERROR from BTrees.OOBTree import OOBTree from ExtensionClass import Base from Acquisition import Implicit, aq_parent from OFS.Traversable import Traversable from OFS.Image import Image as BaseImage from OFS.Cache import ChangeCacheSe... | __all__ = ('Field', 'ObjectField', 'StringField', 'MetadataField', | def getContentType(self, instance): img = self.getRaw(instance) if img: return img.getContentType() return '' |
from Registry import registerField registerField(StringField, title='String', description='Used for storing simple strings') registerField(FileField, title='File', description='Used for storing files') registerField(TextField, title='Text', description=('Used for storing text which can be ' 'used in transformations'... | def set(self, instance, value, **kw): if isinstance(value, StringType): value = StringIO(value) image = ScalableImage(self.name, file=value, displays=self.displays) ObjectField.set(self, instance, image, **kw) | |
'original_size': (600,600), | 'original_size': None, | def isBinary(self): return 1 |
keys = {'height':int(w or h), 'width':int(h or w)} | keys = {'height':int(h), 'width':int(w)} | def scale(self,data,w,h): """ scale image (with material from ImageTag_Hotfix)""" #make sure we have valid int's keys = {'height':int(w or h), 'width':int(h or w)} |
str(obj.getId).strip()) or \ | str(obj.getId()).strip()) or \ | def Vocabulary(self, content_instance=None): #If we have a method providing the list of types go with it, #it can always pull allowed_types if it needs to (not that we #pass the field name) value = ObjectField.Vocabulary(self, content_instance) if value: return value results = [] if self.allowed_types: catalog = getToo... |
if hasattr(self, 'aq_parent'): parent = self.aq_parent parent.manage_renameObjects((self.id,), (value,),\ getattr(self, 'REQUEST', None)) self.id = value | parent = aq_parent(aq_inner(self)) if parent is not None: parent.manage_renameObject( self.id, value, getattr(self, 'REQUEST', None) ) self._setId(value) | def setId(self, value): if value != self.getId(): if hasattr(self, 'aq_parent'): parent = self.aq_parent parent.manage_renameObjects((self.id,), (value,),\ getattr(self, 'REQUEST', None)) self.id = value |
datum = accessor(mimetype="text/plain") | datum = method(mimetype="text/plain") | def SearchableText(self): """full indexable text""" data = [] for field in self.Schema().fields(): if field.searchable != 1: continue method = getattr(self, field.accessor) try: datum = accessor(mimetype="text/plain") except TypeError: # retry in case typeerror was raised because accessor doesn't # handle the mimetype... |
res = 0 return res | def validate_field(self, name, value, errors): """ write a method: validate_foo(new_value) -> "error" or None If there is a validate method defined for a given field invoke it by name name -- the name to register errors under value -- the proposed new value errors -- dict to record errors in """ | |
nodes[sob.UID()] = target | nodes[sob.UID()] = source | def local_refernece_graph(inst): nodes = {} graphs = { 'forward' : {}, 'backward' : {}, } rc = inst.reference_catalog references = rc.getReferences(inst) back_references = rc.getBackReferences(inst) node = Node(inst) nodes[inst.UID()] = node for ref in references: tob = ref.getTargetObject() target = Node(tob) if ... |
from Testing import ZopeTestCase from ArchetypesTestCase import ArchetypesTestCase | def Xprint(s): """print helper print data via print is not possible, you have to use ZopeTestCase._print or this function """ ZopeTestCase._print(str(s)+'\n') | |
data=image.data | data=str(image.data) | def set(self, instance, value, **kwargs): # do we have to delete the image? if value=="DELETE_IMAGE": ObjectField.set(self, instance, None, **kwargs) return |
pairs.append((abs_paths[b.getPath()].UID, label(b))) | if abs_paths.has_key(b.getPath()): pairs.append((abs_paths[b.getPath()].UID, label(b))) | def assign(x, y): abs_paths[x]=y |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.