class StaticSite(PrefixURLMixin, Item): implements(ISessionlessSiteRootPlugin, # implements both so that it ISiteRootPlugin) # works in both super and sub # stores. typeName = 'static_web_site' schemaVersion = 2 prefixURL = text() staticContentPath = text() sessioned = boolean(default=False) sessionless = boolean(default=True) def __str__(self): return '/%s => file(%s)' % (self.prefixURL, self.staticContentPath) def createResource(self): return File(self.staticContentPath) def installSite(self): """ Not using the dependency system for this class because it's only installed via the command line, and multiple instances can be installed. """ for iface, priority in self.__getPowerupInterfaces__([]): self.store.powerUp(self, iface, priority)
class LoginMethod(Item): typeName = 'login_method' schemaVersion = 2 localpart = text(doc=""" A local-part of my user's identifier. """, indexed=True, allowNone=False) domain = text(doc=""" The domain part of my user's identifier. [XXX See TODO below] May be None (generally for "system" users). """, indexed=True) internal = boolean(doc=""" Flag indicating whether this is a method maintained by this server, or if it represents an external contact mechanism (such as a third-party email provider) """, allowNone=False) protocol = text(indexed=True, allowNone=False) account = reference(doc=""" A reference to the LoginAccount for which this is a login method. """, allowNone=False) verified = boolean(indexed=True, allowNone=False)
class StaticRedirect(Item, PrefixURLMixin): implements(inevow.IResource, ISessionlessSiteRootPlugin, ISiteRootPlugin) schemaVersion = 2 typeName = 'web_static_redirect' targetURL = text(allowNone=False) prefixURL = text(allowNone=False) sessioned = boolean(default=True) sessionless = boolean(default=True) def __str__(self): return '/%s => url(%s)' % (self.prefixURL, self.targetURL) def locateChild(self, ctx, segments): return self, () def renderHTTP(self, ctx): return URL.fromContext(ctx).click(self.targetURL) def createResource(self): return self
class TestFilter(Item): """ Ultra stupid classifier. Always classifies every message as whatever you tell it to at creation time. """ implements(IHamFilter) powerupInterfaces = (IHamFilter, ) result = boolean(default=False, allowNone=False) test = inmemory() forgotTraining = boolean(default=False) trainCount = integer(default=0) def classify(self, item): return self.result, 0 def forgetTraining(self): self.forgotTraining = True def train(self, spam, message): self.trainCount += 1 # We're only ever called in the context of retraining, so let's make # sure that what we're being told matches the message that we've been # given. if spam: self.test.failUnless(message.hasStatus(SPAM_STATUS)) else: self.test.failUnless(message.hasStatus(CLEAN_STATUS)) self.test.failUnless(message.hasStatus(TRAINED_STATUS))
class PublicWeb(item.Item, website.PrefixURLMixin): """ Fixture for site-wide public-facing content. I implement ISiteRootPlugin and use PrefixURLMixin; see the documentation for each of those for a detailed explanation of my usage. I wrap a L{websharing.SharingIndex} around an app store. I am installed in an app store when it is created. """ implements(ISiteRootPlugin, ixmantissa.ISessionlessSiteRootPlugin) typeName = 'mantissa_public_web' schemaVersion = 3 prefixURL = attributes.text(doc=""" The prefix of the URL where objects represented by this fixture will appear. For the front page this is u'', for other pages it is their respective URLs. """, allowNone=False) application = attributes.reference(doc=""" A L{SubStore} for an application store. """, allowNone=False) installedOn = attributes.reference(doc=""" """) sessioned = attributes.boolean(doc=""" Will this resource be provided to clients with a session? Defaults to False. """, default=False) sessionless = attributes.boolean(doc=""" Will this resource be provided without a session to clients without a session? Defaults to False. """, default=False) def createResource(self): """ When invoked by L{PrefixURLMixin}, return a L{websharing.SharingIndex} for my application. """ pp = ixmantissa.IPublicPage(self.application, None) if pp is not None: warn( "Use the sharing system to provide public pages, not IPublicPage", category=DeprecationWarning, stacklevel=2) return pp.getResource() return SharingIndex(self.application.open())
class Container(item.Item, Containment, _Enhancement): """ A generic L{_Enhancement} that implements containment. """ contentsTemplate = attributes.text( doc=""" Define how the contents of this container are presented to observers. Certain substrings will be given special treatment. @see: L{imaginary.language.ConceptTemplate} """, allowNone=True, default=None) capacity = attributes.integer( doc=""" Units of weight which can be contained. """, allowNone=False, default=1) closed = attributes.boolean( doc=""" Indicates whether the container is currently closed or open. """, allowNone=False, default=False) thing = attributes.reference( doc=""" The object this container powers up. """)
class GrabberConfiguration(item.Item): """ Manages the creation, operation, and destruction of grabbers (items which retrieve information from remote sources). """ schemaVersion = 3 paused = attributes.boolean(doc=""" Flag indicating whether grabbers created by this Item will be allowed to run. """, default=False) privateApplication = dependsOn(PrivateApplication) deliveryAgent = dependsOn(DeliveryAgent) def addGrabber(self, username, password, domain, ssl): # DO IT if ssl: port = 995 else: port = 110 pg = POP3Grabber(store=self.store, username=username, password=password, domain=domain, port=port, config=self, ssl=ssl) # DO IT *NOW* self.scheduler.schedule(pg, extime.Time())
class Donator(Item): implements(IDonator) steamID = text(allowNone=True, doc=u'64-bit SteamID') anonymous = boolean(allowNone=False, doc=u'Display the user publicly?') totalAmount = point2decimal(allowNone=False, default=Decimal('0')) @property def donations(self): return self.powerupsFor(IDonation) def getDonationAmount(self): return Decimal(sum(donation.amount for donation in self.donations)) def addDonation(self, amount, paypalID): donation = Donation(store=self.store, amount=amount, paypalID=paypalID) donation.installOn(self) return donation def calculateTotal(self): """ Calls L{getDonationAmount} and sets L{totalAmount} to the result. """ self.totalAmount = self.getDonationAmount()
class StubStoredMessageAndImplAndSource(item.Item): """ Mock several objects at once: 1. An L{exmess.Message} 2. The 'impl' attribute of that message, typically a L{mimestore.Part} 3. The message file returned from the C{open} method of C{impl}. XXX: This returns something that doesn't conform to the file protocol, but the code that triggers the usage of that protocol isn't triggered by the following tests. """ calledStartedSending = attributes.boolean(default=False) impl = property(lambda s: s) source = property(lambda self: self._source or FilePath(__file__)) _source = None headers = attributes.inmemory() statuses = attributes.inmemory() def open(self): return "HI DUDE" def startedSending(self): self.calledStartedSending = True def addStatus(self, status): if not hasattr(self, 'statuses'): self.statuses = [status] else: self.statuses.append(status)
class RecorderService(Item): """ Minimal L{IService} implementation which remembers if it was ever started. This is used by tests to make sure services get started when they should be. """ implements(IService) started = boolean(doc=""" A flag which is initially false and set to true once C{startService} is called. """, default=False) name = "recorder" def setServiceParent(self, parent): """ Do the standard Axiom thing to make sure this service becomes a child of the top-level store service. """ IServiceCollection(parent).addService(self) def startService(self): """ Remember that this method was called. """ self.started = True def stopService(self): """
class DummyService(Item): """ Service which does nothing but mark itself as run, if it's ever run. After the upgrader it should not be run. """ typeName = 'substore_service_upgrade_stub_service' everStarted = boolean(default=False) implements(IService) name = property(lambda: "sucky-service") running = property(lambda: False) def setName(self, name): pass def setServiceParent(self, parent): pass def disownServiceParent(self): pass def startService(self): self.everStarted = True def stopService(self): pass def privilegedStartService(self): pass
class VendingMachine(item.Item, objects.Containment, Enhancement): implements(iimaginary.IContainer) capacity = attributes.integer(doc=""" Units of weight which can be contained. """, allowNone=False, default=1) closed = attributes.boolean(doc=""" Indicates whether the container is currently closed or open. """, allowNone=False, default=True) thing = attributes.reference(doc=""" The object this container powers up. """) _currencyCounter = attributes.integer(doc=""" The number of coins which have been added to this vending machine since it last ejected an item. """, allowNone=False, default=0) def coinAdded(self, coin): """ Called when a coin is added to this thing. @type coin: C{ICoin} provider """ self._currencyCounter += 1 if self._currencyCounter >= 5 and self.getContents(): self._currencyCounter = 0 try: obj = iter(self.getContents()).next() except StopIteration: evt = events.Success( actor=self.thing, target=obj, otherMessage=language.Sentence([self.thing, " thumps loudly."])) else: evt = events.Success( actor=self.thing, target=obj, otherMessage=language.Sentence([ language.Noun(self.thing).definiteNounPhrase(), " thumps loudly and spits out ", obj, " onto the ground."])) state = self.closed self.closed = False try: obj.moveTo(self.thing.location) finally: self.closed = state evt.broadcast() def add(self, obj): coin = ICoin(obj, None) if coin is not None: self.coinAdded(coin) else: return super(VendingMachine, self).add(obj)
class MessageInfo(item.Item): typeName = 'quotient_pop3_message' schemaVersion = 2 localPop3UID = attributes.bytes() localPop3Deleted = attributes.boolean(indexed=True) message = attributes.reference()
class NullRunnable(Item): """ Runnable item which does nothing. """ ran = boolean(default=False) def run(self): pass
class YouShouldStartThis(Item, Service): parent = inmemory() running = inmemory() name = inmemory() started = boolean(default=False) def startService(self): self.started = True
class _DependencyConnector(Item): """ I am a connector between installed items and their targets. """ installee = reference(doc="The item installed.") target = reference(doc="The item installed upon.") explicitlyInstalled = boolean(doc="Whether this item was installed" "explicitly (and thus whether or not it" "should be automatically uninstalled when" "nothing depends on it)")
class FakeApplication(Item): """ Fake implementation of an application installed by an offering. """ implements(IPublicPage) index = boolean(doc=""" Flag indicating whether this application wants to be included on the front page. """)
class Recording(Item): """ A certain recording. """ created = timestamp() caller_id = text() filename = text() duration = integer() # in frames use_in_ending = boolean() user_recording = boolean() def filenameAsPath(self, app): """ Return absolute filename without extension """ return app.recordingsPath.child(self.filename).path def filenameAsURL(self): """ Return filename as MP3 url """ return "/recordings/" + self.filename + ".mp3" def filenameAsAsterisk(self): return "weareforests-recordings/%s" % self.filename @staticmethod def userRecordingFilename(app): """ Generate a new filename for a user recording. """ base = "user-%d" % time.time() fn = base f = app.recordingsPath.child(fn) i = 1 while f.exists(): fn = base + ("-%d" % i) f = app.recordingsPath.child(fn) i += 1 return fn
class ScheduleCallingItem(Item): """ Item which invokes C{schedule} on its store's L{IScheduler} from its own C{run} method. """ ran = boolean(default=False) rescheduleFor = timestamp() def run(self): scheduler = IScheduler(self.store) scheduler.schedule(self, self.rescheduleFor) self.ran = True
class CalendarEntry(Item): typeName = 'db_caldate' schemaVersion = 1 # The FQ name of the entry owner (ie, [email protected]) owner = bytes() # All the bits of the date (easier to process chunks like this than a timestamp object) day = integer() month = integer() year = integer() # Start time hourS = integer() minuteS = integer() # End time hourE = integer() minuteE = integer() # The description descrip = bytes() # Should the user get emailed an allert for this emailAlert = boolean() # Repeats: 0 - does not repeat, 1- repeats every day, 2- repeats weekly, 3- repeats monthly, 4- repeays yearly repeats = integer() # Should I set a vacation message during this date :-) vacation = boolean() # Even if the users calander is shared, hide this particular one private = boolean() # Ehash ehash = bytes()
class TestItem(item.Item): schemaVersion = 1 typeName = 'TestItem' foo = attributes.integer(indexed=True, default=10) bar = attributes.text() baz = attributes.timestamp() other = attributes.reference() booleanT = attributes.boolean() booleanF = attributes.boolean() activated = attributes.inmemory() checkactive = attributes.inmemory() checked = attributes.inmemory() myStore = attributes.reference() attributes.compoundIndex(bar, baz) def activate(self): self.activated = True if getattr(self, 'checkactive', False): assert isinstance(self.other, TestItem), repr(self.other) assert self.other != self, repr(self.other) self.checked = True
class CustomizedEnhancement(Item, Enhancement): """ An enhancement which has customized apply / remove behavior. """ thing = reference(allowNone=False) applied = boolean() removed = boolean() def applyEnhancement(self): """ The enhancement is about to be applied; modify our attributes to account for that. """ self.applied = True super(CustomizedEnhancement, self).applyEnhancement() def removeEnhancement(self): """ The enhancement is about to be removed; modify our attributes to account for that. """ self.removed = True super(CustomizedEnhancement, self).removeEnhancement()
class PrivateThing(Item): implements(IPrivateThing, IReadOnly) publicData = integer(indexed=True) externalized = boolean() typeName = 'test_sharing_private_thing' schemaVersion = 1 def mutateSomeState(self): self.publicData += 5 def retrieveSomeState(self): """ Retrieve my public data. """ return self.publicData
class POP3UID(item.Item): grabberID = attributes.text(doc=""" A string identifying the email-address/port parts of a configured grabber """, indexed=True) value = attributes.bytes(doc=""" A POP3 UID which has already been retrieved. """, indexed=True) failed = attributes.boolean(doc=""" When set, indicates that an attempt was made to retrieve this UID, but for some reason was unsuccessful. """, indexed=True, default=False)
class Container(item.Item, Containment, _Enhancement): """A generic powerup that implements containment.""" capacity = attributes.integer(doc=""" Units of weight which can be contained. """, allowNone=False, default=1) closed = attributes.boolean(doc=""" Indicates whether the container is currently closed or open. """, allowNone=False, default=False) thing = attributes.reference(doc=""" The object this container powers up. """)
class Status(item.Item): """ Represents the latest status of a particular grabber. """ when = attributes.timestamp(doc=""" Time at which this status was set. """) message = attributes.text(doc=""" A short string describing the current state of the grabber. """) success = attributes.boolean(doc=""" Flag indicating whether this status indicates a successful action or not. """) changeObservers = attributes.inmemory(doc=""" List of single-argument callables which will be invoked each time this status changes. """) def __repr__(self): return '<Status %r>' % (self.message, ) def activate(self): self.changeObservers = [] self.message = u"idle" def addChangeObserver(self, observer): self.changeObservers.append(observer) return lambda: self.changeObservers.remove(observer) def setStatus(self, message, success=True): self.when = extime.Time() self.message = message self.success = success for L in self.changeObservers: try: L(message) except: log.err(None, "Failure in status update")
class TracebackViewer(Item): implements(INavigableElement) typeName = 'mantissa_tb_viewer' schemaVersion = 2 allowDeletion = boolean(default=False) privateApplication = dependsOn(PrivateApplication) powerupInterfaces = (INavigableElement,) def getTabs(self): return [webnav.Tab('Admin', self.storeID, 0.0, [webnav.Tab('Errors', self.storeID, 0.3)], authoritative=False)] def _getCollector(self): def ifCreate(coll): installOn(coll, self.store.parent) return self.store.parent.findOrCreate(TracebackCollector, ifCreate)
class Installation(Item): """ I represent a collection of functionality installed on a user store. I reference a collection of powerups, probably designated by a Product. """ types = textlist() _items = textlist() suspended = boolean(default=False) def items(self): """ Loads the items this Installation refers to. """ for id in self._items: yield self.store.getItemByID(int(id)) items = property(items) def allPowerups(self): return set(chain(self.items, *[installedRequirements(self.store, i) for i in self.items])) allPowerups = property(allPowerups) def install(self): """ Called when installed on the user store. Installs my powerups. """ items = [] for typeName in self.types: it = self.store.findOrCreate(namedAny(typeName)) installOn(it, self.store) items.append(str(it.storeID).decode('ascii')) self._items = items def uninstall(self): """ Called when uninstalled from the user store. Uninstalls all my powerups. """ for item in self.items: uninstallFrom(item, self.store) self._items = []
# XXX This really should use in-database state, otherwise a restart in # the middle will muck things up. def go(): for msg in work: for f in filters: f.train(msg._spam, msg) yield None self.reclassify() return coiterate(go()) registerAttributeCopyingUpgrader(Filter, 1, 2) item.declareLegacyItem(Filter.typeName, 2, dict(installedOn = attributes.reference(), usePostiniScore = attributes.boolean(default=False,allowNone=False), postiniThreshhold = attributes.ieee754_double(default=0.03))) def _filter2to3(old): """ add dependencies as attributes, remove installedOn """ filter = old.upgradeVersion(old.typeName, 2, 3) s = old.store filter.usePostiniScore = old.usePostiniScore filter.postiniThreshhold = old.postiniThreshhold filter.messageSource = s.findOrCreate(MessageSource) filter.tiSource = s.findOrCreate(_TrainingInstructionSource) return filter
declareLegacyItem( Inbox.typeName, 2, dict(installedOn=attributes.reference(), uiComplexity=attributes.integer(), catalog=attributes.reference()), ) registerAttributeCopyingUpgrader(Inbox, 2, 3) declareLegacyItem( Inbox.typeName, 3, dict( installedOn=attributes.reference(), catalog=attributes.reference(), uiComplexity=attributes.integer(), showMoreDetail=attributes.boolean(), ), ) def inbox3to4(old): """ Copy over all attributes except for 'installedOn' and 'catalog', which have been deleted. To avoid triggering an Axiom bug where installOn will load the Inbox instance being upgraded and re-entrantly run its remaining upgraders, rely on inbox4to5 to set the 'filter' attribute which was added in this version of the schema either to a L{xquotient.spam.Filter} that exists in the store, or to a new one. """
class LinkEntryComment(Item): implements(IFulltextIndexable) typeName = 'eridanus_plugins_linkdb_linkentrycomment' schemaVersion = 1 created = timestamp(doc=""" Timestamp of when this comment was created. """, defaultFactory=lambda: Time()) parent = reference(doc=""" L{LinkEntry} item this comment refers to. """, indexed=True, allowNone=False, reftype=LinkEntry) nick = text(doc=""" The nickname of the person who commented on L{parent}. """, allowNone=False) comment = text(doc=""" The comment text that L{nick} made. """, allowNone=False) initial = boolean(doc=""" Indicates whether this was the initial comment made when the entry was created. """, allowNone=False, default=False) def __repr__(self): return '<%s %s: %r>' % (type(self).__name__, self.nick, self.comment) def stored(self): # Tell the batch processor that we have data to index. s = self.store.findUnique(LinkEntryCommentSource) s.itemAdded() def getEntry(self): return self.parent @property def displayTimestamp(self): """ Convert the C{self.created} timestamp into a human-readable string. """ return self.created.asHumanly(tzinfo=const.timezone) @property def humanReadable(self): """ Display this comment's information in a concise, human-readble string. """ return u'#%d: %s -- \002%s\002 (%s)' % (self.parent.eid, self.comment, self.nick, self.displayTimestamp) # IFulltextIndexable def uniqueIdentifier(self): return str(self.storeID) def textParts(self): yield self.comment
class LinkEntry(Item): implements(IFulltextIndexable) typeName = 'eridanus_plugins_linkdb_linkentry' schemaVersion = 1 eid = integer(doc=""" The ID of this entry. """, indexed=True, allowNone=False) created = timestamp(doc=""" Timestamp of when this entry was created. """, defaultFactory=lambda: Time()) modified = timestamp(doc=""" Timestamp of when this entry was last modified. """, defaultFactory=lambda: Time()) channel = text(doc=""" The channel where this entry was first submitted. """, indexed=True, allowNone=False) nick = text(doc=u""" The nickname of the person who submitted this entry first. """, allowNone=False) url = text(doc=u""" Entry's URL. """, indexed=True, allowNone=False) title = text(doc=u""" Optional title for this entry. """) occurences = integer(doc=""" Number of times this entry has been mentioned. """, default=1) isDiscarded = boolean(doc=""" Indicates whether this item is to be considered for searches and the like. """, default=False) isDeleted = boolean(doc=""" Indicates whether this item is to be considered at all. """, default=False) def __repr__(self): return '<%s %s %s>' % (type(self).__name__, self.canonical, self.url) def stored(self): # Tell the batch processor that we have data to index. s = self.store.findUnique(LinkEntrySource) s.itemAdded() def getEntry(self): return self def getComments(self, initial=None): criteria = [LinkEntryComment.parent == self] if initial is not None: criteria.append(LinkEntryComment.initial == initial) return iter(self.store.query(LinkEntryComment, AND(*criteria), sort=LinkEntryComment.created.ascending)) @property def comments(self): util.deprecation('This is legacy crap, use getComments rather') return self.getComments(initial=False) @property def initialComment(self): util.deprecation('This is legacy crap, use getInitialComment rather') return self.getInitialComment() @property def displayComment(self): comment = self.getInitialComment() if comment is None: return u'' return u' [%s]' % (comment.comment,) @property def slug(self): for slug in reversed(self.url.split('/')): if slug: return urllib.unquote(slug) @property def displayTitle(self): def getMetadata(): metadata = self.getMetadata() contentType = metadata.get(u'contentType') if contentType is not None: yield contentType if contentType.startswith('image'): dims = metadata.get(u'dimensions') if dims is not None: yield dims size = metadata.get(u'size') if size is not None: yield size if self.title is not None: title = self.title else: comment = self.getInitialComment() if comment is not None: title = comment.comment else: title = self.slug md = list(getMetadata()) if md: title = u'%s [%s]' % (title, u' '.join(md),) return title @property def displayTimestamp(self): return self.created.asHumanly(tzinfo=const.timezone) @property def displayModifiedTimestamp(self): return self.modified.asHumanly(tzinfo=const.timezone) def displayCompleteHumanReadable(self, modified=False): if modified: timestamp = u'modified %s' % (self.displayModifiedTimestamp,) else: timestamp = u'posted %s' % (self.displayTimestamp,) return u'#%d: \037%s\037%s @ %s %s by \002%s\002.' % (self.eid, self.displayTitle, self.displayComment, self.url, timestamp, self.nick) # XXX: these properties suck, they should all be replaced with functions # and the some of them merged @property def completeHumanReadable(self): return self.displayCompleteHumanReadable() @property def humanReadable(self): return u'#%d: \037%s\037%s posted %s by \002%s\002.' % (self.eid, self.displayTitle, self.displayComment, self.displayTimestamp, self.nick) @property def canonical(self): return u'#%d.%s' % (self.eid, self.channel) def getInitialComment(self): try: return self.getComments(initial=True).next() except StopIteration: return None def _getMetadata(self): return self.store.query(LinkEntryMetadata, LinkEntryMetadata.entry == self) def getMetadata(self): return dict((md.kind, md.data) for md in self._getMetadata()) def addComment(self, nick, comment): """ Add a comment to this entry. If this is the first comment made by the original author of the entry, it is specially marked as the initial comment. See L{self.getInitialComment}. @type nick: C{unicode} @param nick: Nickname of the person commenting on this entry @type comment: C{unicode} @param comment: Comment content @rtype: L{LinkEntryComment} @return: The newly created comment """ initial = self.getInitialComment() is None and nick == self.nick return self.store.findOrCreate(LinkEntryComment, parent=self, nick=nick, comment=comment, initial=initial) def touchEntry(self): """ Update the modification time and number of occurences of this entry. """ self.modified = Time() self.occurences += 1 # XXX: does anything use this? #def getMetadataByKind(self, kind): # """ # Get all L{LinkEntryMetadata} items associated with this entry. # """ # return self.store.query(LinkEntryMetadata, # AND(LinkEntryMetadata.entry == self, # LinkEntryMetadata.kind == kind)) def updateMetadata(self, metadata): """ Update this entry's metadata. @type metadata: C{dict} @param metadata: A mapping of metadata kinds to metadata data to use for updating this entry's metadata """ store = self.store for kind, data in metadata.iteritems(): md = store.findOrCreate(LinkEntryMetadata, entry=self, kind=kind) md.data = data # IFulltextIndexable def uniqueIdentifier(self): return str(self.storeID) def textParts(self): yield self.url if self.title is not None: yield self.title
return [webnav.Tab('Admin', self.storeID, 0.0, [webnav.Tab('Errors', self.storeID, 0.3)], authoritative=False)] def _getCollector(self): def ifCreate(coll): installOn(coll, self.store.parent) return self.store.parent.findOrCreate(TracebackCollector, ifCreate) # this needs to be moved somewhere else, topPanelContent is no more #def topPanelContent(self): # # XXX There should really be a juice protocol for this. # return '%d errors logged' % (self._getCollector().tracebackCount,) declareLegacyItem(TracebackViewer, 1, dict(allowDeletion=boolean(default=False))) def _tracebackViewer1to2(old): return old.upgradeVersion(TracebackViewer.typeName, 1, 2, allowDeletion=old.allowDeletion, privateApplication=old.store.findOrCreate(PrivateApplication)) registerUpgrader(_tracebackViewer1to2, TracebackViewer.typeName, 1, 2) class TracebackViewerFragment(rend.Fragment): implements(INavigableFragment) live = False fragmentName = 'traceback-viewer' def head(self):
port = 110 pg = POP3Grabber( store=self.store, username=username, password=password, domain=domain, port=port, config=self, ssl=ssl) # DO IT *NOW* self.scheduler.schedule(pg, extime.Time()) # OR MAYBE A LITTLE LATER item.declareLegacyItem(GrabberConfiguration.typeName, 1, dict( paused=attributes.boolean(default=False), installedOn=attributes.reference())) def _grabberConfiguration1to2(old): new = old.upgradeVersion(GrabberConfiguration.typeName, 1, 2, paused=old.paused, privateApplication = old.store.findOrCreate(PrivateApplication), deliveryAgent = old.store.findOrCreate(DeliveryAgent)) return new registerUpgrader(_grabberConfiguration1to2, GrabberConfiguration.typeName, 1, 2) item.declareLegacyItem(GrabberConfiguration.typeName, 2, dict( paused=attributes.boolean(default=False), scheduler=attributes.reference(), privateApplication=attributes.reference(), deliveryAgent=attributes.reference(),
def test_boolean(self): self._test_typeFor(attributes.boolean(), amp.Boolean)