class EventLog(Persistent): """An EventLog encapsulates a collection of log entries.""" def __init__(self): self._data = IOBTree() security = ClassSecurityInfo() security.declarePrivate('addEntry') def addEntry(self, entry): """Add a new log entry.""" if len(self._data): key = self._data.minKey() - 1 else: key = MAX32 self._data[key] = entry security.declarePrivate('getEntries') def getEntries(self): """Return a sequence of log entries.""" return self._data.values() def __len__(self): return len(self._data) def __nonzero__(self): return len(self._data) > 0
def clear(self): """ See IPluggableIndex. """ self._depth = 0 self._index = OOBTree() self._unindex = IOBTree() self._length = Length(0)
def addEdge(self, start, end, edgetype, **kwargs): _id = self.edgeid() if type(edgetype) != int: edgetype = self.typeid(edgetype) if type(start) == dict: start = start['_id'] if type(end) == dict: end = end['_id'] edge = [start, end, edgetype] self.edges[_id] = edge if kwargs: self.edgedata[_id] = kwargs le = self.lightEdge(_id, edge) self.edge_catalog.index_doc(_id, le) le = self.lightEdge(_id, edge) # edgeid:nodeid data = self.outgoing.setdefault(edgetype, IOBTree()).setdefault(start, {}) data[_id] = end self.outgoing[edgetype][start] = data data = self.incoming.setdefault(edgetype, IOBTree()).setdefault(end, {}) data[_id] = start self.incoming[edgetype][end] = data return le
def __init__(self): """Setup our data structures""" self._anon_ratings = IOBTree() self._ratings = OOBTree() self._sessions = OOBTree() self._length = Length() self._anon_length = Length()
def _convertBTrees(self, threshold=200): if type(self._lexicon) is type(''): # Turn the name reference into a hard reference. self._lexicon=self.getLexicon() if type(self._index) is IOBTree: return from BTrees.convert import convert _index=self._index self._index=IOBTree() def convertScores(scores, type=type, TupleType=TupleType, IIBTree=IIBTree ): if type(scores) is not TupleType and type(scores) is not IIBTree(): scores=IIBTree(scores) return scores convert(_index, self._index, threshold, convertScores) _unindex=self._unindex self._unindex=IOBTree() convert(_unindex, self._unindex, threshold)
def __getitem__(self, item): if isinstance(item, slice): _slice = self._reslice(item) return ( IOBTree.__getitem__(self, index) for index in range( _slice.start, min(len(self), _slice.stop), _slice.step ) ) elif isinstance(item, int): if item >= len(self): raise IndexError try: if not item: return IOBTree.__getitem__(self, 0) return IOBTree.__getitem__(self, item > 0 and item or len(self) + item) except KeyError as ex: raise IndexError(ex) else: raise TypeError( f"Invalid LargeList key '{item}'. It must be an integer or a slice." )
def clear(self): self.data = IOBTree() # {rid -> record as tuple} self.indexes = {} # {index_name -> OOBTree({value -> IITreeSet})} self.primary_index = OIBTree() # {primary key -> rid} for position, column in self.col_info: if column.indexed: self.indexes[column.name] = OOBTree()
def clear(self): """Empty the lexicon. """ self.length = Length() self._wid_length_based = False self._wids = OIBTree() # word -> wid self._words = IOBTree() # wid -> word
def clear(self): """Reinitialize the text index.""" self._index = IOBTree() self._unindex = IOBTree() if self.getLexicon() and self.vocabulary_id=='__userdefined__': self.getLexicon().clear() self._lexicon = None
def __init__(self): super(ContentTypeScopeManager, self).__init__() self._mappings = IOBTree() # Methods permitted to access this mapping with. Originally # I wanted to provide alternative sets of mapping on a per # mapping_id basis, however this proved to be complex and # complicated due to extra relationships involved. self._methods = IOBTree() # For metadata related to the above. self._mappings_metadata = IOBTree() # To ease the usage of scopes, the mappings are referenced by # names and are called profiles which add a few useful fields to # allow slightly easier usage. This separates the name from the # already active tokens such that once a token is instantiated # with a scope, the mapping is stuck until the token is revoked. self._named_mappings = OIBTree() # name to id. # To not overburden the named mappings with work-in-progress # profiles, instantiate one here also. self._edit_mappings = OOBTree() self.default_mapping_id = self.addMapping({})
def _convertBTrees(self, threshold=200): if type(self._lexicon) is type(''): # Turn the name reference into a hard reference. self._lexicon = self.getLexicon() if type(self._index) is IOBTree: return from BTrees.convert import convert _index = self._index self._index = IOBTree() def convertScores(scores, type=type, TupleType=TupleType, IIBTree=IIBTree): if type(scores) is not TupleType and type(scores) is not IIBTree(): scores = IIBTree(scores) return scores convert(_index, self._index, threshold, convertScores) _unindex = self._unindex self._unindex = IOBTree() convert(_unindex, self._unindex, threshold)
def clear(self): """Reinitialize the text index.""" self._index = IOBTree() self._unindex = IOBTree() if self.getLexicon() and self.vocabulary_id == '__userdefined__': self.getLexicon().clear() self._lexicon = None
def reset(self): # wid -> {docid -> weight}; t -> D -> w(D, t) # Different indexers have different notions of term weight, but we # expect each indexer to use ._wordinfo to map wids to its notion # of a docid-to-weight map. # There are two kinds of OOV words: wid 0 is explicitly OOV, # and it's possible that the lexicon will return a non-zero wid # for a word we don't currently know about. For example, if we # unindex the last doc containing a particular word, that wid # remains in the lexicon, but is no longer in our _wordinfo map; # lexicons can also be shared across indices, and some other index # may introduce a lexicon word we've never seen. # A word is in-vocabulary for this index if and only if # wid in _wordinfo. Note that wid 0 must not be a key. # This does not use the BTree family since wids are always "I" # flavor trees. self._wordinfo = IOBTree() # docid -> weight # Different indexers have different notions of doc weight, but we # expect each indexer to use ._docweight to map docids to its # notion of what a doc weight is. self._docweight = self.family.IF.BTree() # docid -> WidCode'd list of wids # Used for un-indexing, and for phrase search. self._docwords = self.family.IO.BTree() # Use a BTree length for efficient length computation w/o conflicts self.word_count = Length.Length() self.indexed_count = Length.Length()
def __init__(self, lexicon): self._lexicon = lexicon # wid -> {docid -> weight}; t -> D -> w(D, t) # Different indexers have different notions of term weight, but we # expect each indexer to use ._wordinfo to map wids to its notion # of a docid-to-weight map. # There are two kinds of OOV words: wid 0 is explicitly OOV, # and it's possible that the lexicon will return a non-zero wid # for a word we don't currently know about. For example, if we # unindex the last doc containing a particular word, that wid # remains in the lexicon, but is no longer in our _wordinfo map; # lexicons can also be shared across indices, and some other index # may introduce a lexicon word we've never seen. # A word is in-vocabulary for this index if and only if # _wordinfo.has_key(wid). Note that wid 0 must not be a key. self._wordinfo = IOBTree() # docid -> weight # Different indexers have different notions of doc weight, but we # expect each indexer to use ._docweight to map docids to its # notion of what a doc weight is. self._docweight = IIBTree() # docid -> WidCode'd list of wids # Used for un-indexing, and for phrase search. self._docwords = IOBTree() # Use a BTree length for efficient length computation w/o conflicts self.length = BTrees.Length.Length()
def __init__(self, id=None, **kwargs): super(TracListing, self).__init__(id, **kwargs) # manage an index of parent-to-child, int parent ticket id key # to PersistentList of int ticket id value: self._children = IOBTree() # indexes for score and reward-ratio values: self._scores = IIBTree() # int (ticket#) -> int (sum/score) self._reward = IOBTree() # int (ticket#) -> float (ratio)
def __init__(self): self.timeouts = IOBTree() self.locks = OOBTree() if self.__class__ is LockStorage: raise TypeError( "%s.LockStorage is insane; use a persistent subclass instead" " (%s.PersistentLockStorage should do nicely)" % (__name__, __name__))
def clear(self): """Empty the index""" self._length = Length() self._end2uid = OOBTree() self._start2uid = OOBTree() self._uid2end = IOBTree() # Contains the index used in _end2uid self._uid2duration = IOBTree() # Contains the duration self._uid2start = IOBTree() self._uid2recurrence = IOBTree()
def initializeRoomBookingDB(location, force=False): """ Modifies Indico main database. - location list Creates necessary branches in room booking database. - rooms branch - bookings branch - several indexes """ indicoRoot = MaKaC.common.DBMgr.getInstance().getDBConnection().root() root = DALManagerCERN().getRoot() # 1. Location ----------------------------------------------------------- initialLocation = Location(location, FactoryCERN) if force or not indicoRoot.has_key('RoomBookingLocationList'): indicoRoot['RoomBookingLocationList'] = [initialLocation] if force or not indicoRoot.has_key('DefaultRoomBookingLocation'): indicoRoot['DefaultRoomBookingLocation'] = location # 2. Rooms & Bookings --------------------------------------------------- # Create rooms branch if force or not root.has_key('Rooms'): root['Rooms'] = IOBTree() # Create reservations branch if force or not root.has_key('Reservations'): root['Reservations'] = IOBTree() # Create blocking branch if force or not root.has_key('RoomBlocking'): root['RoomBlocking'] = OOBTree() root['RoomBlocking']['Blockings'] = IOBTree() root['RoomBlocking']['Indexes'] = OOBTree() root['RoomBlocking']['Indexes']['OwnerBlockings'] = OOBTree() root['RoomBlocking']['Indexes']['DayBlockings'] = CalendarDayIndex() root['RoomBlocking']['Indexes']['RoomBlockings'] = OOBTree() # Create indexes if force or not root.has_key('RoomReservationsIndex'): root['RoomReservationsIndex'] = OOBTree() if force or not root.has_key('UserReservationsIndex'): root['UserReservationsIndex'] = OOBTree() if force or not root.has_key('DayReservationsIndex'): root['DayReservationsIndex'] = OOBTree() if force or not root.has_key('RoomDayReservationsIndex'): root['RoomDayReservationsIndex'] = OOBTree() # Create possible equipment branch if force or not root.has_key('EquipmentList'): root['EquipmentList'] = {} # update Catalog with new rb indexes Catalog.updateDB() DALManagerCERN().commit()
def clear(self): """Start over fresh.""" self._always = IITreeSet() self._since_only = IOBTree() self._until_only = IOBTree() self._since = IOBTree() self._until = IOBTree() self._unindex = IOBTree() # 'datum' will be a tuple of date ints self._length = Length()
def clear(self): self._length = Length() self._index = OOBTree() self._unindex = IOBTree() if self._counter is None: self._counter = Length() else: self._increment_counter()
def __init__(self, storage, db=None, scan_interval=10): self.storage = storage self.db = db self.next_conn_id = 1 self.conn_oids = IOBTree() # IOBTree({ conn_id -> OOSet([oid]) } }) self.oids = OOSet() # OOSet([oid]) self.lock = allocate_lock() self.scan_interval = scan_interval self.next_scan = time() + scan_interval
class BranchInfo(Implicit, Persistent): """A utility class to hold branch (line-of-descent) information. It maintains the name of the branch, the version id of the root of the branch and indices to allow for efficient lookups.""" security = ClassSecurityInfo() def __init__(self, name, root): # m_order maintains a newest-first mapping of int -> version id. # m_date maintains a mapping of a packed date (int # of minutes # since the epoch) to a lookup key in m_order. The two structures # are separate because we only support minute precision for date # lookups (and multiple versions could be added in a minute). self.date_created = time.time() self.m_order = IOBTree() self.m_date = IIBTree() self.name = name self.root = root security.declarePublic('getId') def getId(self): """Return the name of the object as string.""" return self.name security.declarePrivate('append') def append(self, version): """Append a version to the branch information. Note that this does not store the actual version, but metadata about the version to support ordering and date lookups.""" if len(self.m_order): key = self.m_order.minKey() - 1 else: key = MAX32 self.m_order[key] = version.id timestamp = int(version.date_created / 60.0) self.m_date[timestamp] = key security.declarePrivate('versionIds') def versionIds(self): """Return a newest-first sequence of version ids in the branch.""" return self.m_order.values() security.declarePrivate('latest') def latest(self): """Return the version id of the latest version in the branch.""" mapping = self.m_order if not len(mapping): return self.root return mapping[mapping.keys()[0]] def __len__(self): return len(self.m_order)
def __init__(self, *pipeline): self._wids = OIBTree() # word -> wid self._words = IOBTree() # wid -> word # wid 0 is reserved for words that aren't in the lexicon (OOV -- out # of vocabulary). This can happen, e.g., if a query contains a word # we never saw before, and that isn't a known stopword (or otherwise # filtered out). Returning a special wid value for OOV words is a # way to let clients know when an OOV word appears. self.wordCount = Length() self._pipeline = pipeline
def __init__(self): self.bookings = OOBTree() # we need real randomness for object keys # but we cannot use the same uid for zope.catalog ids # because it does not support 128bit integers # (and we do not like to use zope.intid). # So, we use different keys for storage and catalog # and we store mapping between them here. self.mapping = IOBTree() self.catalog = setup_catalog()
def sync(self): adapter = self._adapter() self._children = IOBTree() # reset all parent/child refs q = 'status!=closed' for number in adapter.select(q): if str(number) not in self.objectIds(): if number in (self.visible_tickets or []): self._add(number, adapter) else: self.get(str(number)).sync()
def clear(self): """ clear catalog """ self.data = IOBTree() # mapping of rid to meta_data self.uids = OIBTree() # mapping of uid to rid self.paths = IOBTree() # mapping of rid to uid self._length = BTrees.Length.Length() for index in self.indexes.keys(): self.getIndex(index).clear()
def initializeRoomBookingDB(location, force=False): """ Modifies Indico main database. - location list Creates necessary branches in room booking database. - rooms branch - bookings branch - several indexes """ indicoRoot = MaKaC.common.DBMgr.getInstance().getDBConnection().root() root = DALManagerCERN().root # 1. Location ----------------------------------------------------------- initialLocation = Location(location, FactoryCERN) if force or not indicoRoot.has_key('RoomBookingLocationList'): indicoRoot['RoomBookingLocationList'] = [initialLocation] print "Locations branch created (Indico db)" if force or not indicoRoot.has_key('DefaultRoomBookingLocation'): indicoRoot['DefaultRoomBookingLocation'] = location print "Default location set to " + location # 2. Rooms & Bookings --------------------------------------------------- # Create rooms branch if force or not root.has_key('Rooms'): root['Rooms'] = IOBTree() print "Rooms branch created" # Create reservations branch if force or not root.has_key('Reservations'): root['Reservations'] = IOBTree() print "Reservations branch created" # Create indexes if force or not root.has_key('RoomReservationsIndex'): root['RoomReservationsIndex'] = OOBTree() print "Room => Reservations Index branch created" if force or not root.has_key('UserReservationsIndex'): root['UserReservationsIndex'] = OOBTree() print "User => Reservations Index branch created" if force or not root.has_key('DayReservationsIndex'): root['DayReservationsIndex'] = OOBTree() print "Day => Reservations Index branch created" # Create possible equipment branch if force or not root.has_key('EquipmentList'): root['EquipmentList'] = {} print "Equipment branch created" AvatarHolder().invalidateRoomManagerIdList() print "Cached list of room managers invalidated" DALManagerCERN().commit()
def __init__(self, name, root): # m_order maintains a newest-first mapping of int -> version id. # m_date maintains a mapping of a packed date (int # of minutes # since the epoch) to a lookup key in m_order. The two structures # are separate because we only support minute precision for date # lookups (and multiple versions could be added in a minute). self.date_created = time.time() self.m_order = IOBTree() self.m_date = IIBTree() self.name = name self.root = root
def clear(self): """Start over fresh.""" self._always = IITreeSet() self._since_only = IOBTree() self._until_only = IOBTree() self._since = IOBTree() self._until = IOBTree() self._unindex = IOBTree() # 'datum' will be a tuple of date ints self._length = Length() if self._counter is None: self._counter = Length() else: self._increment_counter()
def _init(self): self.nodes = IOBTree() self.edges = IOBTree() self.edgedata = IOBTree() self.outgoing = IOBTree() self.incoming = IOBTree() self.typeids = PObject() self._nodeid = Length(0) self._edgeid = Length(0) self._typeid = Length(0)
def __init__(self): curdir = os.path.abspath(os.path.dirname(__file__)) db_file = os.path.join(curdir, 'OData.db') storage = FileStorage.FileStorage(db_file) db = DB(storage) conn = db.open() self.dbroot = conn.root() if 'zcalibdb' not in self.dbroot: self.dbroot['zcalibdb'] = OOBTree() zcalibdb = self.dbroot['zcalibdb'] zcalibdb['members'] = IOBTree() zcalibdb['books'] = IOBTree() zcalibdb['circulations'] = IOBTree() self.commit()
class OrderFormStorage(Persistent): implements(IOrderFormStorage) def __init__(self): self.storage = IOBTree() self.indeces = OOBTree() def getData(self, min_timestamp=None, max_timestamp=None): if min_timestamp and max_timestamp: indeces = self.indeces['timestamp'].keys( min=min_timestamp, max=max_timestamp ) else: indeces = [] result = [] for i in indeces or self.storage.keys(): data = self.storage[i] data.update({'id': i}) result.append(data) return result def addToIndex(self, index, key, value): if index not in self.indeces: self.indeces[index] = OOBTree() self.indeces[index][key] = value def addOrder(self, order, title='', uid=''): if len(self.storage) == 0: new_key = 0 else: new_key = self.storage.maxKey() new_key += 1 new_dict = {} for key in order.keys(): new_dict[key] = order[key] new_dict['timestamp'] = DateTime() new_dict['title'] = title new_dict['uid'] = uid self.storage[new_key] = new_dict self.addToIndex('timestamp', new_key, new_dict['timestamp'])
def createEvent(self, obj, date, eventType=None, eventSpan=None, handleEventSpan=True): '''Create a new event in the calendar, at some p_date (day). If p_eventType is given, it is used; else, rq['eventType'] is used. If p_handleEventSpan is True, we will use p_eventSpan (or rq["eventSpan"] if p_eventSpan is not given) and also create the same event for successive days.''' obj = obj.o # Ensure p_obj is not a wrapper. rq = obj.REQUEST # Get values from parameters if not eventType: eventType = rq['eventType'] if handleEventSpan and not eventSpan: eventSpan = rq.get('eventSpan', None) # Split the p_date into separate parts year, month, day = date.year(), date.month(), date.day() # Check that the "preferences" dict exists or not. if not hasattr(obj.aq_base, self.name): # 1st level: create a IOBTree whose keys are years. setattr(obj, self.name, IOBTree()) yearsDict = getattr(obj, self.name) # Get the sub-dict storing months for a given year if year in yearsDict: monthsDict = yearsDict[year] else: yearsDict[year] = monthsDict = IOBTree() # Get the sub-dict storing days of a given month if month in monthsDict: daysDict = monthsDict[month] else: monthsDict[month] = daysDict = IOBTree() # Get the list of events for a given day if day in daysDict: events = daysDict[day] else: daysDict[day] = events = PersistentList() # Create and store the event, excepted if an event already exists. if not events: event = Object(eventType=eventType) events.append(event) # Span the event on the successive days if required if handleEventSpan and eventSpan: nbOfDays = min(int(eventSpan), self.maxEventLength) for i in range(nbOfDays): date = date + 1 self.createEvent(obj, date, handleEventSpan=False)
def _mapFromParams(self, params): self._normaliseAuthorParams(params) self._primaryAuthors = IOBTree() self._secondaryAuthors = IOBTree() maxId = -1 for idx in range(len(params["auth_id"])): id = int(params["auth_id"][idx]) if id > maxId: maxId = id author = self._getAuthorFromParams(idx, params) if author["auth_primary"]: self._primaryAuthors[id] = author else: self._secondaryAuthors[id] = author self._nextId = maxId + 1
def _mapFromParams( self, params ): self._normaliseAuthorParams( params ) self._primaryAuthors = IOBTree() self._secondaryAuthors = IOBTree() maxId = -1 for idx in range( len( params["auth_id"] ) ): id = int( params["auth_id"][idx] ) if id>maxId: maxId = id author = self._getAuthorFromParams( idx, params ) if author["auth_primary"]: self._primaryAuthors[ id ] = author else: self._secondaryAuthors[ id ] = author self._nextId = maxId+1
def insert(self, idx, results, relnames=None, treePrefix=None): for brain in results: rid = brain.getRID() path = brain.getPath() if treePrefix and not path.startswith(treePrefix): paths = brain.global_catalog._catalog.indexes['path']._unindex[ rid] for p in paths: if p.startswith(treePrefix): path = p break else: paths = [path] for path in paths: path = path.split('/', 3)[-1] if relnames: if isinstance(relnames, basestring): relnames = (relnames, ) for relname in relnames: path = path.replace('/' + relname, '') if rid: # TODO review this I just did it to avoid exception self._brains[rid] = brain for depth in xrange(path.count('/') + 1): comp = idx.setdefault(path, IOBTree()) comp.setdefault(depth, []).append(rid) path = path.rsplit('/', 1)[0]
def __init__(self): PersistentMapping.__init__(self) self.blogs = IOBTree() self.categories = Categories() self.tags = Tags()
def __init__(self): ouiPath = os.getenv("ICT_OUI_PATH") if ouiPath is not None: f = open(ouiPath, "r") #oui: http://standards.ieee.org/regauth/oui/oui.txt else: f = open("src/org/ict_ok/libs/oui.txt", "r") #oui: http://standards.ieee.org/regauth/oui/oui.txt self._data = IOBTree() last_mac = None EOF = False re_mac = re.compile(r"[A-F0-9]*\-[A-F0-9]*\-[A-F0-9]*") while not EOF: line = f.readline() if re.match(re_mac, line): last_mac = int(line[:8].replace("-", ""), 16) index = line.rfind("\t")+len("\t") org = line[index:].strip() self._data[last_mac] = {"short": org, "other":[]} elif last_mac != None: index = line.rfind("\t") if index != -1: index += len("\t") other = line[index:].strip() self._data[last_mac]["other"].append(other) if (line == "\n"): country_index = len(self._data[last_mac]["other"])-1 #last element self._data[last_mac]["country"] = self._data[last_mac]["other"][country_index] del self._data[last_mac]["other"][country_index] if line == '': EOF=True f.close()
def __init__(self, principalId): self.index = OIBTree() self.messages = IOBTree() self.services = OOBTree() self.readstatus = IITreeSet() self.principalId = principalId self._next = Length(1)
def _clear_and_rebuild(self, ids=[]): """ """ self._positionId = IOBTree() self._idPosition = OIBTree() for id in ids: self.addObject(id)
def clear(self): self._nextid = BTrees.Length.Length() self._forward_idx = OIBTree() self._inverse_idx = IOBTree() if self.truncate_left: self._lforward_idx = OIBTree() else: self._lforward_idx = None
def __init__(self, id=None): super(LinkCheckTool, self).__init__(id) # This is the work queue; items in this queue are scheduled # for link validity check. self.queue = CompositeQueue() # This is the link database. It maps a hyperlink index to a # tuple (timestamp, status, referers). self.checked = IOBTree() # Indexes self.index = OIBTree() self.links = IOBTree() # This is a counter that allows us to add new hyperlinks and # provide an indexc quickly. self.counter = 0
class ActionLogger(Persistent): """ ``IActionLogItem`` container. This is used in `Products.Naaya.NySite` site manager.""" interface.implements(IActionLogger) def __init__(self): super(ActionLogger, self).__init__() self.container = IOBTree() def append(self, log): """ Add an ``IActionLog``""" assert IActionLogItem in interface.providedBy(log), "%s must implementation of IActionLogItem" % log try: new_id = self.container.maxKey() + 1 except ValueError: new_id = 1 self.container[new_id] = log return new_id def create(self, **kw): """ Convenience function """ log = ActionLogItem(**kw) return self.append(log) def items(self, type=None): """ Return container items filtered by type""" if type is None: return self.container.items() return filter(lambda (log_id, log): log.type == type, self.container.items()) def __iter__(self): return self.container.iteritems() def __getitem__(self, key): return self.container[key] def __delitem__(self, key): del self.container[key] def __len__(self): return len(self.container)
def __init__( self, conference): """ Constructor. conference must be a Conference object (not an id). """ self._conference = conference self._contribution_index = IOBTree() #lists of users with reviewing roles self._reviewersList = [] self._editorsList = [] self._refereesList = [] self._paperReviewManagersList = [] self.setChoice(self.NO_REVIEWING) #initial reviewing mode: no reviewing #default dates self._startSubmissionDate = None self._endSubmissionDate = None self._defaultRefereeDueDate = None self._defaultEditorDueDate = None self._defaultReviwerDueDate = None #auto e-mails self._enablePRMEmailNotif = True self._enableRefereeEmailNotif = False self._enableEditorEmailNotif = False self._enableReviewerEmailNotif = False self._enableRefereeEmailNotifForContribution = False self._enableEditorEmailNotifForContribution = False self._enableReviewerEmailNotifForContribution = False self._enableRefereeJudgementEmailNotif = False self._enableEditorJudgementEmailNotif = False self._enableReviewerJudgementEmailNotif = False self._enableAuthorSubmittedMatRefereeEmailNotif = False self._enableAuthorSubmittedMatEditorEmailNotif = False self._enableAuthorSubmittedMatReviewerEmailNotif = False self._enableEditorSubmittedRefereeEmailNotif = False self._enableReviewerSubmittedRefereeEmailNotif = False self._statuses = [] # list of content reviewing and final judgement self._reviewingQuestions = [] #list of content reviewing and final judgement questions self._layoutQuestions = [] #list of layout editing criteria self._templates = {} #dictionary with layout templates. key: id, value: Template object self._templateCounter = Counter(1) #counter to make new id's for the templates self._userCompetences = {} #dictionary with the competences of each user. key: user, value: list of competences self._userCompetencesByTag = {} #dictionary with the users for each competence. key: competence, value: list of users self._reviewingMaterials = {} self.notifyModification() # id generators self._statusCounter = Counter(1) self._questionCounter = Counter(1) self._answerCounter = Counter(1) self.addStatus("Accept", False) self.addStatus("To be corrected", False) self.addStatus("Reject", False)
def setTags(self, pid, oid, tags): self.removeTags(pid, oid) if not tags: return t = [] for tag in tags: tag = tag.lower().strip() if tag: t.append(tag) if not t: return tags = t pdata = self.tags.get(pid) if pdata is None: pdata = IOBTree() self.tags[pid] = pdata oids = pdata.get(oid) if oids is None: oids = OOSet() pdata[oid] = oids oids.update(tags) # insert oid -> pid reference oids = self.oids.get(oid) if oids is None: oids = OOSet() self.oids[oid] = oids oids.insert(pid) #update tagging engine engine = self.getEngine(pid) try: engine.update(oid, tags) except: engine.clear() engine.update(oid, tags)