Python Event.new_for_values方法代码示例

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	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))

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	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))

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
    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]

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	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()

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	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)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	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))

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	def testFindFilteredByEventButNotSubject(self):
		# revision [email protected] (1185)
		# Fix _build_templates so that it works when the Subject is empty.
		self.testSingleInsertGet()
		result = self.findEventIdsAndWait([Event.new_for_values(
			interpretation=Interpretation.LEAVE_EVENT)])
		self.assertEquals(0, len(result))

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
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)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
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)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
	def testSetDataSourceDisabled(self):
		# Insert a data-source -- it should be enabled by default
		self.client._registry.RegisterDataSource(*self._ds1)
		ds = list(self.client._registry.GetDataSources())[0]
		self.assertEquals(ds[DataSource.Enabled], True)

		# Now we can choose to disable it...
		self.client._registry.SetDataSourceEnabled(self._ds1[0], False)
		ds = list(self.client._registry.GetDataSources())[0]
		self.assertEquals(ds[DataSource.Enabled], False)

		event = Event.new_for_values(
			interpretation="interpretation",
			manifestation="manifestation",
			actor="actor",
			subject_uri="some uri",
			subject_manifestation="!stfu:File")

		# ... which will block its events from being inserted
		ids = self.insertEventsAndWait([event])
		self.assertEquals(ids[0], 0)

		# And enable it again!
		self.client._registry.SetDataSourceEnabled(self._ds1[0], True)
		ds = list(self.client._registry.GetDataSources())[0]
		self.assertEquals(ds[DataSource.Enabled], True)

		ids = self.insertEventsAndWait([event])
		self.assertEquals(ids[0], 1)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
    def log_folder_shared(self, share, share_id):
        """Log the 'directory shared' event."""
        fullpath = share.path
        folder_name = basename(fullpath)

        folder = Subject.new_for_values(
            uri=URI_PROTOCOL_U1 + str(share.node_id),
            interpretation=Interpretation.FOLDER,
            manifestation=Manifestation.REMOTE_DATA_OBJECT,
            origin="file:///" + fullpath,
            text=folder_name,
            mimetype=DIRECTORY_MIMETYPE,
            storage=STORAGE_NETWORK)

        other_username = share.other_username
        other_user = Subject.new_for_values(
            uri="mailto:" + other_username,
            interpretation=INTERPRETATION_U1_CONTACT,
            text=other_username,
            manifestation=MANIFESTATION_U1_CONTACT_DATA_OBJECT)

        event = Event.new_for_values(
            interpretation=EVENT_INTERPRETATION_U1_FOLDER_SHARED,
            manifestation=Manifestation.USER_ACTIVITY,
            actor=ACTOR_UBUNTUONE,
            subjects=[folder, other_user])

        self.zg.log(event)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
    def send_to_zeitgeist(self, db, entry, event_type):
        song = self.get_song_info(db, entry)

        if self.__manual_switch:
            manifest = Manifestation.USER_ACTIVITY
        else:
            manifest = Manifestation.SCHEDULED_ACTIVITY

        subject = Subject.new_for_values(
            uri=song["location"],
            interpretation=unicode(Interpretation.AUDIO),
            manifestation=unicode(Manifestation.FILE_DATA_OBJECT),
            #~ origin="", #TBD
            mimetype=song["mimetype"],
            text=" - ".join([song["title"], song["artist"], song["album"]])
        )
        event = Event.new_for_values(
            timestamp=int(time.time()*1000),
            interpretation=unicode(event_type),
            manifestation=unicode(manifest),
            actor="application://rhythmbox.desktop",
            subjects=[subject,]
        )
        #print event
        IFACE.insert_event(event)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
    def handle_AQ_DOWNLOAD_FINISHED(self, share_id, node_id, server_hash):
        """A file finished downloading from the server."""

        mdo = self.fsm.get_by_node_id(share_id, node_id)
        path = self.fsm.get_abspath(share_id, mdo.path)

        if (share_id, node_id) in self.newly_created_local_files:
            self.newly_created_local_files.remove((share_id, node_id))
            event_interpretation = Interpretation.CREATE_EVENT
        else:
            event_interpretation = Interpretation.MODIFY_EVENT

        mime, interp = self.get_mime_and_interpretation_for_filepath(path)

        file_subject = Subject.new_for_values(
            uri="file:///" + path,
            interpretation=interp,
            manifestation=Manifestation.FILE_DATA_OBJECT,
            origin=URI_PROTOCOL_U1 + str(node_id),
            text=basename(path),
            mimetype=mime,
            storage=STORAGE_LOCAL)

        event = Event.new_for_values(
            interpretation=event_interpretation,
            manifestation=Manifestation.WORLD_ACTIVITY,
            actor=ACTOR_UBUNTUONE,
            subjects=[file_subject])

        self.zg.log(event)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
    def handle_AQ_UNLINK_OK(self, share_id, parent_id, node_id,
                            new_generation, was_dir, old_path):
        """A file or folder was deleted on the server by Syncdaemon,"""
        if was_dir:
            mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
        else:
            mime, interp = self.get_mime_and_interpretation_for_filepath(
                                                                    old_path)

        file_subject = Subject.new_for_values(
            uri=URI_PROTOCOL_U1 + str(node_id),
            interpretation=interp,
            manifestation=Manifestation.DELETED_RESOURCE,
            origin="file:///" + old_path,
            text=basename(old_path),
            mimetype=mime,
            storage=STORAGE_DELETED)

        event = Event.new_for_values(
            interpretation=Interpretation.DELETE_EVENT,
            manifestation=Manifestation.SCHEDULED_ACTIVITY,
            actor=ACTOR_UBUNTUONE,
            subjects=[file_subject])

        self.zg.log(event)

# 需要导入模块: from zeitgeist.datamodel import Event [as 别名]
# 或者: from zeitgeist.datamodel.Event import new_for_values [as 别名]
def buildQuery(chromosome):
  storage = StorageState.Any
  numResults = 10
  if chromosome[0] == 0 or chromosome[1] == 0:
    timerange = TimeRange.always()
  else:
    timerange = (chromosome[0]*60*60*24, chromosome[1]*60*60*24)
    if timerange[0] > timerange[1]:
       timerange = (timerange[1], timerange[0])
  searchType = chromosome[2]%30

  eventTemplate = {}
  subjectTemplate = {}

  if chromosome[3]%2 == 0:
    subjectTemplate['interpretation'] = random.choice(list(Interpretation.EVENT_INTERPRETATION.get_children()))
  if chromosome[4]%2 == 0:
    subjectTemplate['manifestation'] = random.choice(list(Manifestation.EVENT_MANIFESTATION.get_children()))
  if chromosome[5]%2 == 0:
    eventTemplate['actor'] = "application://google-chrome.desktop"
  if chromosome[6]%2 == 0:
    subjectTemplate['origin'] = "http://google.com"
  if chromosome[7]%2 == 0:
    subjectTemplate['uri'] = "http://google.com"
  if chromosome[8]%2 == 0:
    subjectTemplate['mimetype'] = "text/html"
  if chromosome[9]%2 == 0:
    subjectTemplate['text'] = "fish"
  if chromosome[10]%2 == 0:
    eventTemplate['manifestation'] = random.choice(list(Manifestation.EVENT_MANIFESTATION.get_children()))
  if chromosome[11]%2 == 0:
    eventTemplate['interpretation'] = random.choice(list(Interpretation.EVENT_INTERPRETATION.get_children()))
  templates = [Event.new_for_values(subjects=[Subject.new_for_values(**subjectTemplate)], **eventTemplate)]

  return (timerange, templates, storage, numResults, searchType)