Python datamodel.Event类代码示例

	def testFindEventTwoInterpretations(self):
		import_events("test/data/twenty_events.js", self)
		result = self.findEventIdsAndWait([
			Event.new_for_values(interpretation="stfu:OpenEvent"),
			Event.new_for_values(interpretation="stfu:EvilEvent")],
			timerange = (102, 117), num_events=0, result_type=0)
		self.assertEquals(15, len(result))

	def __init__(self, date):
		next_date = date + datetime.timedelta(days=1)
		# time.mktime coverts from date to secs since epoch
		day_start = time.mktime(date.timetuple())
		# day_end really is the start of the next day
		day_end = time.mktime(next_date.timetuple())
		DayWidget.__init__(self, day_start, day_end)
		
		day_part_widgets = self.view.get_children()
		day_part = day_part_widgets[1]
		day_part.get_events()
		print day_part.events
		
		#self.vbox.remove(self.daylabel)
		
		self.event_timerange = [day_start * 1000, day_end * 1000]
		self.event_templates = (
			Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
			Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
			Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
			Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
		)
		
	
		CLIENT.install_monitor(self.event_timerange, self.event_templates,
			self.notify_insert_handler, self.notify_delete_handler)
			
		self.get_events()

 def _on_uri_changed(self, webview, load_status):
     if self.webview.get_property("load-status") ==\
         WebKit.LoadStatus.FINISHED:
         if self.current_uri != self.webview.get_uri():
             if self.current_uri:
                 event = Event()
                 event.interpretation = Interpretation.LEAVE_EVENT
                 event.manifestation = Manifestation.USER_ACTIVITY
                 event.actor = "application://web.desktop"
                 subject = Subject()
                 subject.uri = self.current_uri
                 subject.mimetype = "text/html"
                 subject.text = self.current_title
                 subject.interpretation = Interpretation.WEBSITE
                 subject.manifestation = Manifestation.REMOTE_PORT_ADDRESS
                 event.subjects = [subject]
                 ZG.insert_event(event)
             self.current_uri = self.webview.get_uri()
             self.current_title = self.webview.get_title()
             print "===>", self.current_title 
             event = Event()
             event.interpretation = Interpretation.ACCESS_EVENT
             event.manifestation = Manifestation.USER_ACTIVITY
             event.actor = "application://web.desktop"
             subject = Subject()
             subject.uri = self.current_uri
             subject.mimetype = "text/html"
             subject.text = self.current_title
             subject.interpretation = Interpretation.WEBSITE
             subject.manifestation = Manifestation.REMOTE_PORT_ADDRESS
             event.subjects = [subject]
             ZG.insert_event(event)

    def __init__(self):
        self[0] = all_events

        template2  = Event.new_for_values(interpretation = \
            Interpretation.ACCESS_EVENT)
        self[1] = ["Access Events", \
                   "Fetch all the access events", \
                   template2, \
                   TimeRange.always(), \
                   ResultType.MostRecentEvents]

        template3  = Event.new_for_values(interpretation = \
            Interpretation.LEAVE_EVENT)
        self[2] = ["Leave Events", \
                   "Fetch all the leave events", \
                   template3, \
                   TimeRange.always(), \
                   ResultType.MostRecentEvents]


        template4  = Event.new_for_values(interpretation = \
            Interpretation.MODIFY_EVENT)
        self[3] = ["Modify Events", \
                   "Fetch all the modify events", \
                   template4, \
                   TimeRange.always(), \
                   ResultType.MostRecentEvents]
        template5 = Event.new_for_values(actor = "application://banshee.desktop")
        self[4] = ["Banshee events", \
                   "All the Banshee related events", \
                   template5, \
                   TimeRange.always(), \
                   ResultType.MostRecentEvents]

	def testMoving(self):
		import_events("test/data/five_events.js", self)
		import_events("test/data/five_events_ext_move.js", self)
		template = Event.new_for_values(subject_current_uri='file:///*')

		ids = self.findEventIdsAndWait([template],
			num_events = 0,
			result_type = ResultType.MostRecentCurrentUri)
		self.assertEquals(2, len(ids))

		ids = self.findEventIdsAndWait([template],
			num_events = 0,
			result_type = ResultType.MostRecentCurrentUri)
		self.assertEquals(2, len(ids))

		ids = self.findEventIdsAndWait([template],
			num_events = 0,
			result_type = ResultType.MostRecentEvents)
		self.assertEquals(5, len(ids))

		template = Event.new_for_values(subject_current_origin='file:///*')
		ids = self.findEventIdsAndWait([template],
			num_events = 0,
			result_type = ResultType.MostRecentEvents)
		self.assertEquals(4, len(ids))

 def _on_view_pages(self, widget):
     self.home.reset()
     uris = []
     for pIndex in xrange(self.pages.get_n_pages()):
         self.pages.set_current_page(pIndex)
         page = self.pages.get_nth_page(pIndex)
         overviewPage = PageOverviewWidget(page)
         overviewPage.connect("clicked", self._on_page_clicked)
         self.home.add_page(overviewPage)
         uris.append(page.webview.get_uri())
     self.home.show_all()
     self.box.set_current_page(0)
     
     def callback(events):
         self.home.recentDashboard.recentPages.reset()
         for event in events:
             page = PageButton(event.subjects[0])
             print event.subjects[0].uri
             self.home.recentDashboard.recentPages.add_page(page)
         self.home.show_all()
     event = Event()
     event.actor = "application://web.desktop"
     event.subjects = []
     for uri in uris:
         if uri:
             subject = Subject()
             subject.uri = "!"+uri
             event.subjects.append(subject)
     print event
     ZG.find_events_for_template(event, callback, result_type=2)

	def _get_base_template(self):
		base_template = Event()
		if self.has_uri:
			subj = Subject()
			subj.set_uri(self.uri+"/*")
			base_template.set_subjects([subj])
		else:
			base_template.set_actor(self.uri)
		return base_template

	def testFindMultipleEvents(self):
		import_events("test/data/five_events.js", self)
		subj1 = Subject.new_for_values(uri="file:///home/foo.txt")
		event_template1 = Event.new_for_values(subjects=[subj1])
		subj2 = Subject.new_for_values(uri="file:///tmp/foo.txt")
		event_template2 = Event.new_for_values(subjects=[subj2])
		result = self.findEventIdsAndWait([event_template1, event_template2], num_events=0, result_type=4)
		self.assertEquals(2, len(result))
		events = self.getEventsAndWait(result)

	def testFindWithSubjectText(self):
		import_events("test/data/five_events.js", self)
		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this is not real')])
		self.assertEquals(0, len(result))
		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='some text')])
		self.assertEquals(1, len(result))
		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this *')])
		self.assertEquals(0, len(result)) # We don't support wildcards for text
		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this item *')])
		self.assertEquals(1, len(result))

	def testUnicodeEventInsert(self):
		# Insert and get a unicode event
		ids = import_events("test/data/unicode_event.js", self)
		self.assertEquals(len(ids), 1)
		result = self.getEventsAndWait(ids)
		self.assertEquals(1, len(result))
		event = result[0]
		self.assertEquals(1, len(event.subjects))
		self.assertEquals(u"hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
		self.assertEquals(u"http://live.gnome.org/☠", event.subjects[0].uri)

		# Update the event we got from the DB's timestamp and insert
		# it again, we want to to test some ping-pong back and forth
		event[0][Event.Id] = ""
		event.timestamp = "243"
		ids = self.insertEventsAndWait([event])
		result = self.getEventsAndWait(ids)
		self.assertEquals(1, len(result))
		event = result[0]
		self.assertEquals(1, len(event.subjects))
		self.assertEquals(u"hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
		self.assertEquals(u"http://live.gnome.org/☠", event.subjects[0].uri)

		# Try and find a unicode event
		subj = Subject.new_for_values(text="hällö, I'm gürmen - åge drikker øl - ☠",
			origin="file:///åges_øl í", uri=u"http://live.gnome.org/☠")
		event_template = Event.new_for_values(subjects=[subj,])

		result = self.findEventIdsAndWait([event_template],
			timerange=(0,200), num_events=100, result_type=0)
		self.assertEquals(len(result), 1)

def post_commit(local, master, old_revno, old_revid, new_revno, new_revid):
    client = get_client()
    if client is None:
        return
    from zeitgeist.datamodel import Event, Interpretation, Manifestation
    revision = master.repository.get_revision(new_revid)
    if new_revno == 1:
        interpretation = Interpretation.CREATE_EVENT
    else:
        interpretation = Interpretation.MODIFY_EVENT
    _text = _("Revision: ")
    _text += str(new_revno) + "\n"
    _text += revision.message.rstrip()

    subjects = subjects_for_branch(master, new_revno, old_revno, 
                None, revision.message.rstrip())
    #subjects.set_text(_text)
    event = Event.new_for_values(
        timestamp=int(revision.timestamp*1000),
        interpretation=unicode(interpretation),
        manifestation=unicode(Manifestation.USER_ACTIVITY),
        actor=get_actor(),
        subjects=subjects,
    )
    client.insert_event(event)

    def onNewTrack(self, track):
        """ Send track information to Zeitgeist """
        import mimetypes, os.path

        from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation

        mime, encoding = mimetypes.guess_type(track.getFilePath(), strict=False)

        subject = Subject.new_for_values(
            uri            = os.path.dirname(track.getURI()),
            text           = track.getTitle() + ' - ' + track.getArtist() + ' - ' + track.getExtendedAlbum(),
            mimetype       = mime,
            manifestation  = unicode(Manifestation.FILE),
            interpretation = unicode(Interpretation.AUDIO),
        )

        if hasattr(Interpretation, 'ACCESS_EVENT'):
            eventType = Interpretation.ACCESS_EVENT
        else:
            eventType = Interpretation.OPEN_EVENT

        event = Event.new_for_values(
            actor          = "application://decibel-audio-player.desktop",
            subjects       = [subject,],
            interpretation = eventType,
        )

        self.client.insert_event(event)

def main(argv):
    interpretation = Interpretation.MODIFY_EVENT.uri

    # FIXME: I'd be great if zeitgeist would allow for more detail:
    #           * branch
    #           * log summary (git log -1 --format=%s HEAD)
    curdir = os.path.abspath(os.curdir).decode(sys.getfilesystemencoding())
    uri = u"file://%s" % curdir

    repo, origin = get_repo()
    if not repo:
        repo = unicode(curdir.rsplit('/', 1)[1])
        origin = uri

    subject = Subject.new_for_values(
        uri=uri,
        interpretation=Interpretation.DOCUMENT.TEXT_DOCUMENT.PLAIN_TEXT_DOCUMENT.SOURCE_CODE.uri,
        manifestation=Manifestation.FILE_DATA_OBJECT.uri,
        text=repo,
        origin=origin)
    event = Event.new_for_values(
        timestamp=int(time.time() * 1000),
        interpretation=interpretation,
        manifestation=Manifestation.USER_ACTIVITY.uri,
        actor="application://gitg.desktop",
        subjects=[subject])
    CLIENT.insert_event(event)

	def testMonitorInstallRemoval(self):
		result = []
		mainloop = self.create_mainloop()
		tmpl = Event.new_for_values(interpretation="stfu:OpenEvent")
		
		@asyncTestMethod(mainloop)
		def notify_insert_handler(notification_type, events):
			pass
		
		@asyncTestMethod(mainloop)
		def notify_delete_handler(time_range, event_ids):
			mainloop.quit()
			self.fail("Unexpected delete notification")
		
		mon = self.client.install_monitor(TimeRange.always(), [tmpl],
			notify_insert_handler, notify_delete_handler)
		
		@asyncTestMethod(mainloop)
		def removed_handler(result_state):
			result.append(result_state)
			mainloop.quit()
		
		self.client.remove_monitor(mon, removed_handler)
		mainloop.run()
		self.assertEquals(1, len(result))
		self.assertEquals(1, result.pop())

	def insert_event_for_values (self, **values):
		"""
		Send an event to the Zeitgeist event log. The keyword arguments
		must match those as provided to Event.new_for_values().
		
		The insertion will be done via an asynchronous DBus call and
		this method will return immediately. This means that the
		Zeitgeist engine will most likely not have inserted the event
		when this method returns. There will be a short delay.
		
		If the ids_reply_handler argument is set to a callable it will
		be invoked with a list containing the ids of the inserted events
		when they have been registered in Zeitgeist.
		
		In case of errors a message will be printed on stderr, and
		an empty result passed to ids_reply_handler (if set).
		To override this default set the error_handler named argument
		to a callable that takes a single exception as its sole
		argument.
		
		In order to use this method there needs to be a mainloop
		runnning. Both Qt and GLib mainloops are supported.
		"""
		ev = Event.new_for_values(**values)
		self.insert_events([ev],
				values.get("ids_reply_handler", None),
				values.get("error_handler", None))