def __init__(self, code, name, description, base_unit): """Creates a new product""" self.code = code self.name = name self.description = description self.bill_of_materials = PersistentDict() self.bill_of_activities = PersistentDict()
class PersistentDictConfigStorage(DictConfigStorage): def __init__(self, *a, **kw): self._dict = PersistentDict() ConfigStorage.__init__(self, *a, **kw) def getDict(self): site = getSite() if site is not None: ann = IAnnotations(site) if ASSETS_SETTING_KEY not in ann: ann[ASSETS_SETTING_KEY] = self._dict return ann[ASSETS_SETTING_KEY] return self._dict def __getitem__(self, key): key = key.lower() value = self._get_deprecated(key) if not value is None: return value self._dict = self.getDict() return self._dict.__getitem__(key) def __setitem__(self, key, value): key = key.lower() if not self._set_deprecated(key, value): self._dict = self.getDict() self._dict.__setitem__(key, value) self._dict._p_changed = True
def save_form_in_session(context, request): sdm = getToolByName(context, "session_data_manager") session = sdm.getSessionData(create=True) path = "/".join(context.getPhysicalPath()) pdict = PersistentDict() pdict.update(request.form) session.set(path, pdict)
def test_rendering_no_nested_links(self): obj = PersistentDict({1: PersistentFrob()}) obj._p_oid = p64(0x18) self.assertEqual( PersistentDictValue(obj).render(), '<a class="objlink" href="@@zodbbrowser?oid=0x18">' '{1: <PersistentFrob>}</a>')
def __init__(self, name, parent=None): PersistentDict.__init__(self) PersistentLocationAware.__init__(self, name, parent) self.__name__ = name if parent is not None: parent[name] = self self.__parent__ = parent
def add(self, data, index=-1): """Add data to the storage. Data must the a dict-like structure""" row = PersistentDict() row.update(data) if index>-1: self._ann.insert(index, row) else: self._ann.append(row)
def __init__(self, id, title): """ """ self.id = id self.title = title self.config = PersistentDict(self.default_config) self.timestamps = PersistentDict() # Confirmations list self.pending_anonymous_subscriptions = PersistentList()
def __init__(self, name, title, default_language): self.data = PersistentDict() self.order = PersistentDict() self.count = PersistentDict() self.version = PersistentDict() self.name = name self.title = title self.default_language = default_language
def __call__(self): req = self.request settings = Settings(self.context) annotations = settings.annotations if annotations is None: annotations = PersistentDict() settings.annotations = annotations sections = settings.sections if sections is None: sections = PersistentList() settings.sections = sections action = req.form['action'] if action == 'addannotation': page = int(req.form['page']) if page not in annotations: annotations[page] = PersistentList() pageann = annotations[page] data = { "id": random.randint(1, 9999999), "coord": req.form['coord'], "title": req.form.get('title', ''), "content": req.form.get('content', '')} pageann.append(data) return json.dumps(data) elif action == 'removeannotation': page = int(req.form['page']) if page in annotations: ann_id = int(req.form['id']) found = False annotations = annotations[page] for ann in annotations: if ann['id'] == ann_id: found = ann break if found: annotations.remove(found) elif action == 'addsection': data = { 'page': req.form['page'], 'title': req.form['title'] } sections.append(data) return json.dumps(data) elif action == 'removesection': data = { 'page': req.form['page'], 'title': req.form['title'] } if data in sections: sections.remove(data)
def __init__(self, name, description=None, parent=None): PersistentDict.__init__(self) PersistentLocationAware.__init__(self) self.__name__ = name self.__parent__ = parent if description is None: self.description = name else: self.description = description self.preview_picture = None self.preview_size = (-1,-1)
class Amendment(Commentable, CorrelableEntity, SearchableEntity, DuplicableEntity, PresentableEntity): """Amendment class""" icon = 'icon novaideo-icon icon-amendment' name = renamer() result_template = 'novaideo:views/templates/amendment_result.pt' author = SharedUniqueProperty('author') proposal = SharedUniqueProperty('proposal', 'amendments') def __init__(self, **kwargs): super(Amendment, self).__init__(**kwargs) self.explanations = PersistentDict() self.set_data(kwargs) # @region.cache_on_arguments() def get_used_ideas(self): """Return used ideas""" result = [] if not hasattr(self, 'explanations'): return result for explanation in self.explanations.values(): if explanation['intention'] is not None: try: result.extend( Intention.get_explanation_ideas( explanation['intention']) ) except Exception: pass return list(set(result)) @property def related_ideas(self): """Return added ideas""" result = [] for explanation in self.explanations.values(): if explanation['intention'] is not None: try: result.extend( Intention.get_explanation_data( explanation['intention'])['related_ideas'] ) except Exception: pass return list(set(result))
def _fixup(self): # due to compatibility reasons this method fixes data structure # for old Taxonomy instances. # XXX: remove this in version 2.0 to prevent write on read if self.order is None: safeWrite(self, getRequest()) self.order = PersistentDict() self.count = PersistentDict() if self.version is None: safeWrite(self, getRequest()) self.version = PersistentDict()
def add_facet(self, name, **kwargs): """ Add facet >>> _ = visualization.add_facet('country', a=1, b=2) >>> facet = visualization.facet('country') >>> sorted(facet.items()) [('a', 1), ('b', 2), ('label', 'country'), ('name', ...] """ config = self._facets() kwargs.update({'name': name}) kwargs.setdefault('type', u'daviz.list.facet') facet = PersistentDict(kwargs) config.append(facet) return facet.get('name', '')
def add_view(self, name, **kwargs): """ Add view >>> _ = visualization.add_view(name='daviz.map', ... lat='latitude', long='longitude') >>> view = visualization.view('daviz.map') >>> sorted(view.items()) [('lat', 'latitude'), ('long', 'longitude'), ('name', 'daviz.map')] """ config = self._views() kwargs.update({'name': name}) view = PersistentDict(kwargs) config.append(view) return view.get('name', '')
def add_source(self, name, **kwargs): """ Add source >>> _ = visualization.add_source('http://bit.ly/rdf', type='rdf') >>> source = visualization.source('http://bit.ly/rdf') >>> sorted(source.items()) [('name', 'http://bit.ly/rdf'), ('type', 'rdf')] """ config = self._sources() kwargs.update({'name': name}) kwargs.setdefault('type', u'json') source = PersistentDict(kwargs) config.append(source) return source.get('name', '')
class Tool(UniqueObject, SimpleItem): """ Contentrules subscription tool """ id = SUBSCRIPTION_TOOL meta_type = 'Contentrules Subscription Tool' plone_tool = 1 def __init__(self): self.subscriptions = PersistentDict() def registerUser(self, rule_id, email): """ Insert the given email address in the given rule_id """ if not rule_id in self.subscriptions: self.subscriptions[rule_id] = [email] else: if email in self.subscriptions[rule_id]: factory = getUtility(IVocabularyFactory, "contentrules.subscription.vocabularies.SubscriptionRulesVocabulary") vocabulary = factory(self) rule_term = vocabulary.getTerm(rule_id) msg = _('already_subscribed_error', default='The given email is already present for "${title}"', mapping=dict(title=rule_term.title)) return False, msg else: self.subscriptions[rule_id].append(email) return True, "" def getSubscriptions(self): """ Return the list of subscriptions """ return self.subscriptions def getActionUIDS(self): """ return a list of email addresses for the given rule_id """ return self.subscriptions.keys() def getRegisteredList(self, rule_id): """ return a list of email addresses for the given rule_id """ return self.subscriptions.get(rule_id, [])
def test_fix_image_field_modification_time(self): from persistent.dict import PersistentDict title = u'Fix image field modification time' step = self._get_upgrade_step(title) self.assertIsNotNone(step) # simulate state on previous version cover = self._create_cover(id='test-cover', layout='Empty layout') cover.cover_layout = ( '[{"type": "row", "children": [{"column-size": 16, "type": ' '"group", "children": [{"tile-type": ' '"collective.cover.basic", "type": "tile", "id": ' '"ca6ba6675ef145e4a569c5e410af7511"}], "roles": ["Manager"]}]}]') tile = cover.get_tile('ca6ba6675ef145e4a569c5e410af7511') obj = self.portal['my-image'] tile.populate_with_object(obj) dmgr = ITileDataManager(tile) old_data = dmgr.get() old_data['image_mtime'] = repr(old_data['image_mtime']) dmgr.annotations[dmgr.key] = PersistentDict(old_data) data = dmgr.get() self.assertIsInstance(data['image_mtime'], str) # run the upgrade step to validate the update self._do_upgrade_step(step) data = dmgr.get() self.assertIsInstance(data['image_mtime'], float)
def __init__(self, title): self.title = title self.__name__ = normalise_title(title) self._properties = PersistentDict({}) self._extra_behaviour = PersistentList([]) self._update_properties()
def add_change(self, field_id, before, after, field_title=''): self.changes.append(PersistentDict( field_id=field_id, field_title=field_title, # Deprecated, only for the old gever-ui before=before, after=after ))
def concordar_ressalva(context, paragrafo_id, userid=None): """ Concorda com um parágrafo de um item. Se nenhum usuário for passado, o corrente será usado. Se o usuário tinha concordado com o parágrafo previamente, remove tal voto. Se o usuário tinha discordado do item previamente, remove o voto e adiciona um novo de concordância. """ action = None userid = userid or _get_user_id() annotations = IAnnotations(context) if userid in annotations[discordancias][paragrafo_id]: annotations[discordancias][paragrafo_id].pop(userid) if userid in annotations[concordancias][ paragrafo_id] and 'ressalva' in annotations[concordancias][ paragrafo_id][userid]: annotations[concordancias][paragrafo_id].pop(userid) action = "desfazer" event.notify(UnlikeEvent(context)) else: annotations[concordancias][paragrafo_id][userid] = PersistentDict() annotations[concordancias][paragrafo_id][userid]["has_voted"] = True annotations[concordancias][paragrafo_id][userid]["ressalva"] = '' action = "concordar_ressalva" event.notify(LikeEvent(context)) context.reindexObject(idxs=['concordancias']) return action
def test_second_step_required_columns_nok(self): """Test validation of required columns""" request = self.layer["request"] request.form = { "form.buttons.import": u"Importer", "form.widgets.column_0": u"--NOVALUE--", "form.widgets.column_1": u"--NOVALUE--", "form.widgets.column_2": u"--NOVALUE--", "form.widgets.decimal_import": u"False", "form.widgets.allow_empty": u"False", } annotations = IAnnotations(self.container) annotation = annotations[importform.ANNOTATION_KEY] = PersistentDict() annotation["has_header"] = False annotation["separator"] = u";" annotation["source"] = NamedBlobFile( data=self._csv.read(), contentType=u"text/csv", filename=u"test.csv", ) form = importform.ImportFormSecondStep(self.container, request) form.updateFieldsFromSchemata() form.updateWidgets() data, errors = form.extractData() self.assertEqual(1, len(errors)) self.assertEqual( "The following required columns are missing: identifier", translate(errors[0].error.message), )
def _storage(self): return IAnnotations( self.context ).setdefault( PAI_STORAGE_KEY, PersistentDict() )
def getDefault(self, name): try: return self._defaults.get(name) except AttributeError: # Backward compatibility self._defaults = PersistentDict() self.setDefault(name, 'Plone Default') return self.getDefault(name)
def getAllUserRolesInfo(self): state = self._getStorage4UserRolesInfo() auth_tool = self.context.getAuthenticationTool() # add user.roles info for user in auth_tool.getUsers(): userid = user.name roles = user.roles if userid not in state: state[userid] = PersistentList() unsaved_roles = [] for r in roles: has_role = False for su in state[userid]: if r in su['roles']: has_role = True break if not has_role: unsaved_roles.append(r) if unsaved_roles != []: unsaved_roles = PersistentList(unsaved_roles) state[userid].append(PersistentDict({'roles': unsaved_roles})) return state
class Base(object): use_interface = None def __init__(self, context): self.context = context annotations = IAnnotations(self.context) self._metadata = annotations.get('collective.documentviewer', None) if self._metadata is None: self._metadata = PersistentDict() self._metadata['last_updated'] = DateTime('1901/01/01').ISO8601() self.storage_version = STORAGE_VERSION annotations['collective.documentviewer'] = self._metadata def __setattr__(self, name, value): if name[0] == '_' or name in ['context', 'use_interface']: self.__dict__[name] = value else: self._metadata[name] = value def __getattr__(self, name): default = None if name in self.use_interface.names(): default = self.use_interface[name].default elif name in _defaults: default = _defaults.get(name, None) return self._metadata.get(name, default)
class AnnotationAdapter(object): """Abstract Base Class for an annotation storage. If the annotation wasn't set, it won't be created until the first attempt to set a property on this adapter. So, the context doesn't get polluted with annotations by accident. """ ANNOTATION_KEY = None def __init__(self, context): self.context = context annotations = IAnnotations(context) self._data = annotations.get(self.ANNOTATION_KEY, None) def __setattr__(self, name, value): if name in ('context', '_data', 'ANNOTATION_KEY'): self.__dict__[name] = value else: if self._data is None: self._data = PersistentDict() annotations = IAnnotations(self.context) annotations[self.ANNOTATION_KEY] = self._data self._data[name] = value def __getattr__(self, name): return self._data and self._data.get(name, None) or None
class Base(object): use_interface = None def __init__(self, context): self.context = context annotations = IAnnotations(self.context) self._metadata = annotations.get('wc.pageturner', None) if self._metadata is None: self._metadata = PersistentDict() self._metadata['last_updated'] = DateTime('1901/01/01').ISO8601() annotations['wc.pageturner'] = self._metadata def __setattr__(self, name, value): if name[0] == '_' or name in ['context', 'use_interface']: self.__dict__[name] = value else: self._metadata[name] = value def __getattr__(self, name): default = None if name in self.use_interface.names(): default = self.use_interface[name].default return self._metadata.get(name, default)
def __init__(self, parent, form, REQUEST, real_doc=None, validation_mode=False): self._parent = parent self.REQUEST = REQUEST if real_doc: self.items = PersistentDict(real_doc.items) self.setItem('Form', form.getFormName()) self.real_id = real_doc.id form.validateInputs(REQUEST, self) form.readInputs(self, REQUEST, validation_mode=validation_mode) else: self.items = {} self.setItem('Form', form.getFormName()) self.real_id = "TEMPDOC" mapped_field_ids, rowdata = getDatagridRowdata(self, REQUEST) if mapped_field_ids and rowdata: for f in mapped_field_ids: self.setItem(f.strip(), rowdata[mapped_field_ids.index(f)]) else: form.validateInputs(REQUEST, self) form.readInputs(self, REQUEST, validation_mode=validation_mode)
def _annotation_storage(self, create_if_missing=False): annotations = IAnnotations(self.context) # Avoid writes on read if REMINDER_ANNOTATIONS_KEY not in annotations and create_if_missing: annotations[REMINDER_ANNOTATIONS_KEY] = PersistentDict() return annotations.get(REMINDER_ANNOTATIONS_KEY, {})
def getSocialAppConfig(self): if not hasattr(self, '_socialAppConfig'): self._socialAppConfig = PersistentDict({ 'active': False, 'facebook': {} }) return self._socialAppConfig
class DavizSettings(SimpleItem): """ Daviz Settings """ meta_type = "EEA Daviz Settings" security = ClassSecurityInfo() implements(IDavizSettings) id = 'portal_daviz' manage_options = ( {'label': 'Edit', 'action': 'zmi_edit_html'}, ) + SimpleItem.manage_options def __init__(self, p_id, title="all daviz settings"): super(DavizSettings, self).__init__() self._setId(p_id) self.title = title self.settings = PersistentDict() site = getSite() sm = site.getSiteManager() ds = sm.queryUtility(IDavizSettings) if ds: sm.unregisterUtility(ds, IDavizSettings) sm.registerUtility(self, IDavizSettings) def disabled(self, view, content_type): """ Is view disabled for given content_type """ if not isinstance(view, (str, unicode)): view = getattr(view, '__name__', '') if not isinstance(content_type, (str, unicode)): content_type = getattr(content_type, 'portal_type', getattr(content_type, 'meta_type', None)) portal_types = self.settings.get(u'forbidden.%s' % view, None) or [] return content_type in portal_types
def __init__(self, context): annotations = IAnnotations(context) mapping = annotations.get(KEY) if mapping is None: blank = {'email': u'', 'dashboard_objs': AdmUtilUserDashboardSet()} mapping = annotations[KEY] = PersistentDict(blank) self.mapping = mapping
def getAllLDAPGroupRolesInfo(self): state = self._getStorage4LDAPGroupRolesInfo() auth_tool = self.context.getAuthenticationTool() if not hasattr(self.context, 'acl_satellite'): return state mapped_roles = self.context.acl_satellite.getAllLocalRoles() for group in mapped_roles: roles = mapped_roles[group] if group not in state: state[group] = PersistentList() unsaved_roles = [] for r in roles: has_role = False for sg in state[group]: if r in sg['roles']: has_role = True break if not has_role: unsaved_roles.append(r) if unsaved_roles != []: unsaved_roles = PersistentList(unsaved_roles) state[group].append(PersistentDict({'roles': unsaved_roles})) return state
def test_second_step_import_single_column(self): """Test importing csv data""" form = importform.ImportFormSecondStep(self.container, self.layer["request"]) annotations = IAnnotations(self.container) annotation = annotations[importform.ANNOTATION_KEY] = PersistentDict() annotation["has_header"] = False annotation["separator"] = u";" csv = StringIO() lines = [ ["", "key1", "Key 1"], ["", "key2", "Key 2"], ] for line in lines: csv.write(";".join(line) + "\n") csv.seek(0) annotation["source"] = NamedBlobFile( data=csv.read(), contentType=u"text/csv", filename=u"test.csv", ) data = { "column_0": None, "column_1": "identifier", "column_2": None, "decimal_import": False, "allow_empty": False, } form._import(data) self.assertEqual(2, len(self.container)) self.assertEqual(["key1", "key2"], sorted( [e.identifier for e in self.container.values()])) self.assertEqual(["key1", "key2"], sorted([e.title for e in self.container.values()]))
def test_second_step_basic_delimiter(self): """Test edge case related to csv delimiter""" form = importform.ImportFormSecondStep(self.container, self.layer["request"]) annotations = IAnnotations(self.container) annotation = annotations[importform.ANNOTATION_KEY] = PersistentDict() annotation["has_header"] = False annotation["separator"] = u"," csv = StringIO() lines = [ ["", "key1", "Key 1"], ["key1", "key1.1", '"Key 1,1"'], ["key1.1", "key1.1.1", '"Key 1.1.1"'], ] for line in lines: csv.write(",".join(line) + "\n") csv.seek(0) annotation["source"] = NamedBlobFile( data=csv.read(), contentType=u"text/csv", filename=u"test.csv", ) exception = None try: form.update() except Exception as e: exception = e self.assertIsNone(exception)
def __init__(self, id=None): if id is not None: self.id = str(id) self._chains = PersistentDict() self._chainDefaultConfig = DEFAULT_RULES
def test_second_step_import_encoding_form(self): """Test importing csv data with special chars in header and content""" form = importform.ImportFormSecondStep(self.container, self.layer["request"]) annotations = IAnnotations(self.container) annotation = annotations[importform.ANNOTATION_KEY] = PersistentDict() annotation["has_header"] = True annotation["separator"] = u";" csv = StringIO() lines = [ [u"猫".encode("utf8"), u"èè".encode("utf8"), u"ùù".encode("utf8")], ["", u"kéy1".encode("utf8"), u"Kèy 1".encode("utf8")], [ u"kéy1".encode("utf8"), u"kéy1.1".encode("utf8"), u"猫".encode("utf8") ], ] for line in lines: csv.write(";".join(line) + "\n") csv.seek(0) annotation["source"] = NamedBlobFile( data=csv.read(), contentType=u"text/csv", filename=u"test.csv", ) form.update() exception = None try: render = form.render() except UnicodeDecodeError as e: exception = e self.assertIsNone(exception) self.assertTrue(u"Column {0}".format(u"猫") in render)
def __init__(self, nadimak, jeLiRacunalo, igra): self.nadimak = nadimak self.karte = PersistentList() self.igra = igra self.jeLiRacunalo = jeLiRacunalo self.zastavice = PersistentDict() self.zastavice.update({ 'uzmiKarte': 0, 'provjeriZvanja': 0, 'hocuLiZvati': 0, 'baciKartu': 0 }) self.igra.onSudjeluj(self) transaction.commit()
def test_second_step_optional_columns_data_ok(self): """Test validation of optional columns data""" request = self.layer["request"] request.form = { "form.buttons.import": u"Importer", "form.widgets.column_0": u"parent_identifier", "form.widgets.column_1": u"identifier", "form.widgets.column_2": u"title", "form.widgets.column_3": u"informations", "form.widgets.decimal_import": u"False", "form.widgets.allow_empty": u"False", } annotations = IAnnotations(self.container) annotation = annotations[importform.ANNOTATION_KEY] = PersistentDict() annotation["has_header"] = False annotation["separator"] = u";" csv = StringIO() lines = [ ["", "key1", "Key 1", "infos"], ["key1", "key1.1", "Key 1.1", ""], ["key1.1", "key1.1.1", "Key 1.1.1", ""], ] for line in lines: csv.write(";".join(line) + "\n") csv.seek(0) annotation["source"] = NamedBlobFile( data=csv.read(), contentType=u"text/csv", filename=u"test.csv", ) form = importform.ImportFormSecondStep(self.container, request) form.updateFieldsFromSchemata() form.updateWidgets() data, errors = form.extractData() self.assertEqual(0, len(errors))
def get_storage(context, default=None): annotations = IAnnotations(context) if annotation_key not in annotations: if default is not None: return default annotations[annotation_key] = PersistentDict() return annotations[annotation_key]
def set_source_data(self, source_data): if not hasattr(self, 'source_data'): self.source_data = PersistentDict({}) app_name = source_data.get('app_name') self.source_data.setdefault(app_name, {}) self.source_data[app_name] = source_data
def make_persistent(value): if type(value) == list: return PersistentList([make_persistent(i) for i in value]) elif type(value) == dict: return PersistentDict([(i[0], make_persistent(i[1])) for i in value.items()]) return value
class FeedSettings(object): implements(IFeedSettings) adapts(ISyndicatable) def __init__(self, context): self.context = context annotations = IAnnotations(context) self._metadata = annotations.get(FEED_SETTINGS_KEY, None) if self._metadata is None: self._metadata = PersistentDict() annotations[FEED_SETTINGS_KEY] = self._metadata registry = getUtility(IRegistry) self.site_settings = registry.forInterface(ISiteSyndicationSettings) def __setattr__(self, name, value): if name in ('context', '_metadata', 'site_settings'): self.__dict__[name] = value else: self._metadata[name] = value def __getattr__(self, name): default = None if name in ISiteSyndicationSettings.names(): default = getattr(self.site_settings, name) elif name == 'enabled' and self.site_settings.default_enabled: default = True elif name in IFeedSettings.names(): default = IFeedSettings[name].default return self._metadata.get(name, default)
def __init__(self, context, interfaces=[IGallerySettings]): """ The interfaces argument allows you to customize which interface these settings implemenet. """ self.context = context self._interfaces = interfaces if type(self._interfaces) not in (list, tuple): self._interfaces = [self._interfaces] self._interfaces = list(self._interfaces) if IGallerySettings not in self._interfaces: self._interfaces.append(IGallerySettings) if None in self._interfaces: self._interfaces.remove(None) annotations = IAnnotations(context) self._metadata = annotations.get('collective.plonetruegallery', None) if self._metadata is None: self._metadata = PersistentDict() annotations['collective.plonetruegallery'] = self._metadata from collective.plonetruegallery.utils import convertMeasurementToInt self._inline_conversions = { 'nivoslider_width': convertMeasurementToInt, 'nivoslider_height': convertMeasurementToInt }
def _set_field_type(self, value): portal = getSite() anno = IAnnotations(portal) name = 'sllintra.content.field_type' if anno.get(name) is None: anno[name] = PersistentDict() anno[name].update({self.field.getName(): value})
class PortletAssignmentSettings(Contained): def __init__(self): self.data = PersistentDict() def __setitem__(self, name, value): self.data[name] = value def __delitem__(self, name): del self.data[name] def __getitem__(self, name): return self.data.__getitem__(name) def get(self, name, default=None): return self.data.get(name, default)
def save_users_statistics_reports(site, time_periods, reports): """ Input: - the list of time periods (as used in generate_users_statistics()) - the list of reports (as returned by generate_users_statistics()) Save reports as annotations on site in format: '2015/01/01-2015/01/31': { 'active': 300, 'new': 100, 'total': 2000, 'last_update': DateTime } Return True on saved or False for invalid input """ stats_annot = IAnnotations(site).setdefault(USERS_STATISTICS_KEY, PersistentDict({})) if len(time_periods) == len(reports): for i in range(0, len(time_periods)): report = reports[i] report['last_update'] = DateTime() stats_annot[period_title(time_periods[i])] = report print "Saved report: {0}".format(period_title(time_periods[i])) else: return False transaction.commit() return True
def __init__(self, id): """ Initialization """ CMFBTreeFolder.__init__(self, id) self.id = id self.items = PersistentDict() self.plomino_modification_time = DateTime().toZone(TIMEZONE)
def _setupConfigAnnotation(self): """ Make sure that we can store the field config. """ annotations = IAnnotations(self) settings = annotations.get("PLOMINOFIELDCONFIG", None) if not settings: annotations["PLOMINOFIELDCONFIG"] = PersistentDict()
class Base(object): use_interface = None def __init__(self, context): self.context = context annotations = IAnnotations(self.context) self._metadata = annotations.get('vindula.streaming', None) if self._metadata is None: self._metadata = PersistentDict() self._metadata['last_updated'] = DateTime('1901/01/01').ISO8601() self.storage_version = STORAGE_VERSION annotations['vindula.streaming'] = self._metadata def __setattr__(self, name, value): if name[0] == '_' or name in ['context', 'use_interface']: self.__dict__[name] = value else: self._metadata[name] = value def __getattr__(self, name): default = None if name in self.use_interface.names(): default = self.use_interface[name].default elif name in _defaults: default = _defaults.get(name, None) return self._metadata.get(name, default)
class RosterSettings(object): use_interface = None def __init__(self, context, interface): self.use_interface = interface self.context = context annotations = IAnnotations(self.context) self._metadata = annotations.get('collective.eventmanager', None) if self._metadata is None: self._metadata = PersistentDict() annotations['collective.eventmanager'] = self._metadata def __setattr__(self, name, value): if name[0] == '_' or name in ['context', 'use_interface']: self.__dict__[name] = value else: self._metadata[name] = value def __getattr__(self, name): default = None if name in self.use_interface.names(): default = self.use_interface[name].default return self._metadata.get(name, default)
class Base(object): use_interface = None def __init__(self, context): self.context = context annotations = IAnnotations(self.context) self._metadata = annotations.get('wildcard.media', None) def __setattr__(self, name, value): if name[0] == '_' or name in ['context', 'use_interface']: self.__dict__[name] = value else: if self._metadata is None: self._metadata = PersistentDict() annotations = IAnnotations(self.context) annotations['wildcard.media'] = self._metadata self._metadata[name] = value def __getattr__(self, name): default = None if name in self.use_interface.names(): default = self.use_interface[name].default if self._metadata is None: return default return self._metadata.get(name, default)
def test_second_step_basic_encoding(self): """Ensure that form can be displayed even with special characters""" form = importform.ImportFormSecondStep(self.container, self.layer["request"]) annotations = IAnnotations(self.container) annotation = annotations[importform.ANNOTATION_KEY] = PersistentDict() annotation["has_header"] = False annotation["separator"] = u";" csv = StringIO() lines = [ ["null", "key1", "key1.1", "Key 1.1", "informations"], [ "null", "", u"key1 éà$€".encode("utf8"), u"Key 1 éà$€".encode("utf8"), u"informations éà$€".encode("utf8"), ], ] for line in lines: csv.write(";".join(line) + "\n") csv.seek(0) annotation["source"] = NamedBlobFile( data=csv.read(), contentType=u"text/csv", filename=u"test.csv", ) exception = None try: form.update() except UnicodeDecodeError as e: exception = e self.assertIsNone(exception)
def set(self, data): # when setting data, we need to purge scales/image data... # XXX hack? try: scale_key = self.key.replace('.data.', '.scale.') del self.annotations[scale_key] except KeyError: pass for k, v in data.items(): if INamedImage.providedBy(v): mtime_key = '{0}_mtime'.format(k) if (self.key not in self.annotations or k not in self.annotations[self.key] or (self.key in self.annotations and data[k] != self.annotations[self.key][k])): # set modification time of the image notify(Purge(self.tile)) data[mtime_key] = '%f' % time.time() else: data[mtime_key] = self.annotations[self.key].get( mtime_key, '') self.annotations[self.key] = PersistentDict(data) notify(ObjectModifiedEvent(self.context))
def set(self, field_name, value): shared_data = self.shared_data data = shared_data.setdefault(self.related_key, PersistentDict()) if value is None: data[field_name] = None else: data[field_name] = float(value)
def test_persist_simple(self): root = self.conn.root() root['aba'] = PersistentDict() root['aba']['maba'] = 3 self.reopen() root = self.conn.root() self.assertEqual(root['aba']['maba'], 3)
def __init__(self, principalId, store=None): self.principalId = principalId self.data = PersistentDict() # We don't really expect that many # _v_store is used to remember a mapping object that we should # be saved in if we ever change self._v_store = store