Пример #1
0
    def pred_theo_eZero(self, fCol):

        from statistics import mean
        from Compute import Compute
        from Event import Event
        import re

        summary = open('Parameters/fit_' + str(fCol) + '_eZero.txt', 'r')
        out = open('Predicted/pred_' + str(fCol) + '_eZero.txt', 'w')

        cmpt = Compute(self.data)
        evnt = Event(self.data)

        para = []
        for line in summary:
            if re.search('Parameters', line):
                temp = re.findall('Parameters\s\[\s?(.*)\]', line)[0].split()
                for t in temp:  # IF ERROR HERE: Check parameters file for newline commands
                    para.append(float(t))

        # Set estimation specific paramters
        evnt.paraD = para[0:int(len(para) / 2)]
        evnt.paraImp = para[int(len(para) / 2):]

        evnt.event_type = 'eZero'
        evnt.decay_type = 'LongMemory'
        evnt.fCol = fCol

        sqerr = []
        for i in range(len(self.data.events)):
            if self.data.events[i] == 'E':
                pred = cmpt.cmpt_theo_event(i, evnt)
                out.write(
                    str(self.data.tgates[i]) + ' ' + str(pred) + ' ' +
                    str(self.data.prices[i]) + ' ' + str(self.data.bid_1s[i]) +
                    ' ' + str(self.data.ask_1s[i]) + ' \n')
                sqerr.append(abs(pred - self.data.prices[i]))

        print('MAE eZero ' + str(fCol) + ' ' + str(mean(sqerr)))
Пример #2
0
    def read_data_from_file(self, file):
        data_file = self.safe_open(file)
        lines = data_file.readlines()

        for line in lines:
            elements = line.split()
            date = elements[0]
            time = elements[1]

            # checks if data has locations
            if len(elements) == 4:
                sensor = Sensor(elements[2], elements[3], None)
                if elements[2] not in self.sensor_names:
                    self.sensor_names.append([elements[2]])
            else:
                sensor = Sensor(elements[3], elements[4], elements[2])
                if elements[3] not in self.sensor_names:
                    self.sensor_names.append(np.array([elements[3]]))
                if elements[2] not in self.sensor_locations:
                    self.sensor_locations.append(np.array([elements[2]]))

            self.events.append(Event(date, time, sensor))
Пример #3
0
def init_event_objects(events):
    print('Creating event objects ...\n')

    event_objects = []

    for event in events:
        # Retrieve properties that make up an event.
        title = event.h3.a.text
        start_time = event.find('time', class_='dtstart')['datetime']
        end_time = event.find('time', class_='dtend')['datetime']
        location = event.find('span', class_='location').text
        description = event.p.text
        url = 'http://events.ucf.edu' + event.a['href']

        start_time = format_datetime(start_time)
        end_time = format_datetime(end_time)

        # Create an event object with the event properties.
        event_objects.append(
            Event(title, start_time, end_time, location, description, url))

    return event_objects
Пример #4
0
 def __init__(self):
     self.__connectionData = ConnectionData()
     self.__connectionUrl = None
     self.__connectionMethod = CONNECTION_METHOD.BASIC
     self.__connectionStatus = LOGIN_STATUS.NOT_SET
     self.__lastLoginName = None
     self.__hostItem = g_preDefinedHosts._makeHostItem('', '', '')
     self.__retryConnectionPeriod = _MIN_RECONNECTION_TIMEOUT
     self.__retryConnectionCallbackID = None
     g_playerEvents.onKickWhileLoginReceived += self.__processKick
     g_playerEvents.onLoginQueueNumberReceived += self.__processQueue
     self.__eManager = EventManager()
     self.onLoggedOn = Event(self.__eManager)
     self.onConnected = Event(self.__eManager)
     self.onRejected = Event(self.__eManager)
     self.onDisconnected = Event(self.__eManager)
     self.onKickedFromServer = Event(self.__eManager)
     self.onKickWhileLoginReceived = Event(self.__eManager)
     self.onQueued = Event(self.__eManager)
     return
 def __init__(self, file_name):
     line = 0
     self.all_events = []
     self.open_file = file_name
     dict_to_read = dict()
     reading = open(self.open_file, 'r')
     file_list = reading.readlines()
     for x in file_list:
         line += 1
         print('Line', line, 'initialization:')
         line_list = x.split('| ')
         for y in range(0, len(line_list)):
             dict_to_read[self.list_to_read[y]] = line_list[y]
         dict_to_read['date'] = dict_to_read['date'].split('-')
         dict_to_read['time'] = dict_to_read['time'].split(':')
         new_event = Event(dict_to_read)
         if new_event.id != 0:
             self.all_events.append(new_event)
             print('Line', line, 'initialized properly')
         else:
             print('Line', line, 'was not initialized properly')
     reading.close()
Пример #6
0
def getEvent(id):
    """
    Return an event with a given id, if existent.
    """

    log.info('retrieve event ' + str(id))
    with connection:
        cur = connection.cursor()
        cur.execute('SELECT owner, date, amount, participants, comment, status FROM splitpot_events where id = ?'
                    , [id])
        e = cur.fetchone()
        if e:
            return Event(
                id=id,
                owner=str(e[0]),
                date=datetime.datetime.strptime(e[1], DATEFORMAT),
                amount=e[2],
                participants=json.loads(e[3]),
                comment=e[4],
                status=e[5],
                )
        return None
Пример #7
0
    def __add__(self, other):
        """
        Here, we combine two weighters into one super-weighter
        This returns another Wighter object that evaluates the sum of the parent weighters' calculated weights 
        """
        if not isinstance(other, Weighter):
            raise TypeError("Expected {}, got {}".format(
                Weighter, type(other)))

        # create default event
        ev = Event()
        dtype = type(other(ev) + self(ev))

        # make a little meta weighter object. It does weighting!
        class metaWeighter(Weighter):
            def __init__(self_meta, dtype):
                Weighter.__init__(self_meta, dtype)

            def __call__(self_meta, event):
                return (self(event) + other(event))

        return (metaWeighter(dtype))
Пример #8
0
 def __init__(self, browser):
     self.__cursorTypes = {CURSOR_TYPES.Hand: Cursor.HAND,
      CURSOR_TYPES.Pointer: Cursor.ARROW,
      CURSOR_TYPES.IBeam: Cursor.IBEAM,
      CURSOR_TYPES.Grab: Cursor.DRAG_OPEN,
      CURSOR_TYPES.Grabbing: Cursor.DRAG_CLOSE,
      CURSOR_TYPES.ColumnResize: Cursor.MOVE}
     self.__cursorType = None
     self.onLoadStart = Event()
     self.onLoadEnd = Event()
     self.onLoadingStateChange = Event()
     self.onCursorUpdated = Event()
     self.onDOMReady = Event()
     self.onReady = Event()
     self.__urlFailed = False
     self.__browserProxy = weakref.proxy(browser)
     return
Пример #9
0
def event_test():
    numNodes = int(input("num nodes?"))
    numEdges = int(input("num edges?"))

    nodes = []
    edges = []

    for x in range(numNodes):
        nodes.append(int(input("node#" + str(x) + "?")))

    for x in range(numEdges):
        a = int(input("edge#" + str(x) + "? (a)"))
        b = int(input("edge#" + str(x) + "? (b)"))

        edges.append((a, b))

    print(nodes)
    print(edges)

    testEvent = Event()

    for x in nodes:
        testEvent.add_user(x)

    for x in edges:
        testEvent.add_edge(x[0], x[1])

    print(testEvent.export_users())
    print(testEvent.export_edges_directed())
    print(testEvent.export_edges_undirected())

    print("Finding perfect matches")
    print("group: " + str(findPerfectGroup(testEvent, 1, 3)))

    print("Making groups from remaining nodes")
    remaining = forceGroups(testEvent, 3)
    for x in remaining:
        print("group " + str(x))
Пример #10
0
 def __setUpEvent(self):
     """
     initializes events
     :return: None
     """
     for _ in range(self.arrival_num):
         c = random.randint(0,self.__colDimension-1)
         r = random.randint(0,self.__rowDimension-1)
         new_event = Event(self.prob, self.die_expo, self.__colDimension-1, self.__rowDimension-1)
         self.__events[new_event] = (c, r)
         new_event.update_sector(c, r)
         new_event.update_die_time(time.time())
         new_event.update_next_sector()
         stay_time = self.stay_expo()
         new_event.update_next_move_time(time.time() + stay_time)
         copy = list(self.__board[c][r].event_list)
         copy.append(new_event)
         self.__board[c][r].event_list = copy
         self.__total_events += 1
         self.__board[c][r].num_of_events += 1
         self.__board[c][r].time_with_events += stay_time
         self.__total_dur += stay_time
         self.next_add_event_time = time.time() + self.arrival_rate()
Пример #11
0
    def generate_event(self):

        if not self.rule.has_key('event_type'):
            logger.error("Event has no type, check plugin configuration!")
            return None

        if self.rule['event_type'] == Event.EVENT_TYPE:
            event = Event()
        elif self.rule['event_type'] == EventIdm.EVENT_TYPE:
            event = EventIdm()
        else:
            logger.error("Bad event_type (%s) in rule (%s)" % \
                (self.rule["event_type"], self.name))
            return None

        for key, value in self.rule.iteritems():
            if key not in ["regexp", "precheck"]:
                event[key] = self.plugin.get_replace_value(
                    value.encode('utf-8'), self.groups,
                    self._replace_assessment[key])
        if self.log and not event['log'] and "log" in event.EVENT_ATTRS:
            event['log'] = self.log.encode('utf-8')
        return event
    def setUp(self):
        self.eventStore = EventStore.get()
        self.appStore = ApplicationStore.get()
        self.fileFactory = FileFactory.get()
        self.fileStore = FileStore.get()
        self.userConf = UserConfigLoader.get("user.ini")

        self.ar1 = Application("ristretto.desktop",
                               pid=21,
                               tstart=1,
                               tend=2000)
        self.ar2 = Application("ristretto.desktop",
                               pid=22,
                               tstart=2600,
                               tend=2900)
        self.ag1 = Application("gimp.desktop", pid=23, tstart=1, tend=4000)
        self.ag2 = Application("gimp.desktop", pid=24, tstart=4500, tend=4590)
        self.appStore.insert(self.ar1)
        self.appStore.insert(self.ar2)
        self.appStore.insert(self.ag1)
        self.appStore.insert(self.ag2)

        # Insert a file that will bridge r1 and g1.
        s2 = "open64|/home/user/Images/Picture.jpg|fd 4: with flag 524288, e0|"
        e2 = Event(actor=self.ag1, time=10, syscallStr=s2)
        self.eventStore.append(e2)
        e2b = Event(actor=self.ar1, time=12, syscallStr=s2)
        self.eventStore.append(e2b)

        # Insert a file that will bridge r1 and r2.
        s3 = "open64|/home/user/Images/Photo.jpg|fd 10: with flag 524288, e0|"
        e3 = Event(actor=self.ar1, time=10, syscallStr=s3)
        self.eventStore.append(e3)
        e3b = Event(actor=self.ar2, time=2710, syscallStr=s3)
        self.eventStore.append(e3b)

        # Insert a file that will bridge g1 and g2.
        s4 = "open64|/home/user/Images/Art.xcf|fd 10: with flag 524288, e0|"
        e4 = Event(actor=self.ag1, time=10, syscallStr=s4)
        self.eventStore.append(e4)
        e4b = Event(actor=self.ag2, time=4540, syscallStr=s4)
        self.eventStore.append(e4b)

        # Simulate.
        self.eventStore.simulateAllEvents()
Пример #13
0
    def sse_theo_LT(self, para):
        """ Returns the Sum Squared Error """

        from Event import Event

        evnt = Event(self.data)
        evnt.e2_mean_rev1 = para[0]
        evnt.e2_resp1 = para[1]
        evnt.e2_mean_rev2 = para[2]
        evnt.e2_resp2 = para[3]
        evnt.event_type = 'evntLT'
        evnt.decay_type = 'LastTrade'

        error = 0.0
        for i in range(int(len(self.data.events))):
            if self.data.events[i] == 'E':
                est = self.cmpt_theo_event(i, evnt)
                error += (self.data.prices[i] - est)**2
        if self.verbose:
            print('SSE Const ' + str(error) + ' ' + str(para[0]) + ' ' +
                  str(para[1]) + ' ' + str(para[2]) + ' ' + str(para[3]))

        return error
Пример #14
0
 def __init__(self, availableGroupNames):
     self.changed = Event()
     self.__currentType = None
     self.__currentSlotIdx = None
     self.__availableGroupNames = availableGroupNames
     self.__currentGroup = 'all_groups'
     self.__showInDossier = True
     self.__purchaseType = PURCHASE_TYPE.PURCHASE
     self.__rules = {
         FILTER_TYPE.SHOW_IN_DOSSIER: self.__isInDossier,
         FILTER_TYPE.QUALIFIER: self.__hasSelectedBonus,
         FILTER_TYPE.GROUP: self.__isInSelectedGroup,
         FILTER_TYPE.PURCHASE_TYPE: self.__hasPurchaseType
     }
     self.__selectedBonuses = {
         QUALIFIER_TYPE.ALL: False,
         QUALIFIER_TYPE.COMMANDER: False,
         QUALIFIER_TYPE.GUNNER: False,
         QUALIFIER_TYPE.DRIVER: False,
         QUALIFIER_TYPE.RADIOMAN: False,
         QUALIFIER_TYPE.LOADER: False
     }
     return
Пример #15
0
    def sse_theo_eCEP(self, para):
        """ Returns the Sum Squared Error """

        from Event import Event
        evnt = Event(self.data)
        evnt.event_type = 'eOmniPresent'
        evnt.decay_type = 'LongMemory'
        evnt.fCol = self.fCol

        #  Set estimation specific paramters
        evnt.paraD = para[0]
        evnt.paraImp = para[1:]
        # evnt.lots_traded_trigger = round(para[-1])

        error = 0.0
        for i in range(int(len(self.data.events))):
            if self.data.events[i] == 'E':
                est = self.cmpt_theo_event(i, evnt)
                error += (self.data.prices[i] - est)**2
        if self.verbose:
            print(str(error) + ' ' + str(evnt.paraD) + ' ' + str(evnt.paraImp))

        return error
Пример #16
0
def charClassifier(char):
	if(char in [' ', '\t']):
		tipo = 'descartável'
	elif(char != '\n'):
		tipo = 'útil'
	else:
		tipo = 'controle'

	if re.match(r'[a-zA-Z]', char):
		classe = 'letra'
	elif re.match(r'[0-9]', char):
		classe = 'dígito'
	elif char in [' ', '\t']:
		char = 'espaço'
		classe = 'delimitador'
	elif char == '\n':
		char = 'EOL'
		classe = 'controle'
	else:
		classe = 'especial'

	print("charClassifier \tChar: " + char + "\t\tTipo: " + tipo + "\tClasse: " + classe)
	yield Event("ClassificaçãoDeChar", {'char': char, 'char_type': tipo, 'char_class': classe}, engine='lexer')
Пример #17
0
    def setEvent(self,
                 automa,
                 result,
                 obj,
                 typ,
                 duration=1,
                 time2go=0,
                 volume=None):
        """Set event in Object's Event Queue if object is an istance of Automa"""

        if automa.checkClass(obj):
            #(self, typ, volume,  time2go = 1, duration = 1, energy = None, power = None, mass = None
            event = Event(
                typ=typ, volume=volume, duration=duration, time2go=time2go
            )  # duration = 0 -> effetti evento già applicati su object
            obj.insertEvent(event)
            logger.logger.debug(
                "Actuator: {0} result action = {1}. Inserted assimilate event in object's event queue: event._id: {2}, event._typ: {3}, event._volume: {4}, event._time2go: {5}, event._duration: {6}, event._energy: {7}, event._power: {8}, event._mass: {9}"
                .format(self._id, result, event._id, event._type,
                        event._volume, event._time2go, event._duration,
                        event._energy, event._power, event._mass))

        return True
def add_one():
    if user_id == -1:
        return jsonify({'status': '200', 'message': 'Not logged in'})
    param_set = ('duration', 'price', 'rest_name', 'title', 'date', 'time')
    to_give = {}
    for x in param_set:
        if x not in request.args:
            return jsonify({'status': '400', 'message': 'Missing parameters'})
        else:
            to_give[x] = request.args[x]

    cursor.execute("select max(id) from events")
    for x in cursor:
        if x[0] is None:
            max_prev = 0
        else:
            max_prev = x[0]
        to_give['id'] = max_prev + 1
    to_give['user_id'] = user_id
    new_event = Event(to_give)
    if new_event.id == -1:
        return jsonify({
            'status': '400',
            'message': 'wrong input',
            'errors': new_event.errors
        })
    else:
        to_return = all_events.append(new_event)
        if to_return['status'] == '200':
            data = (to_give['id'], to_give['title'], to_give['rest_name'],
                    to_give['date'], to_give['time'], to_give['duration'],
                    to_give['price'], to_give['user_id'])
            to_do = """INSERT INTO events
                    VALUES""" + str(data) + ';'
            cursor.execute(to_do)
            db.commit()
        return jsonify(to_return)
Пример #19
0
    def generate_event(self):

        if not self.rule.has_key('event_type'):
            logger.error("Event has no type, check plugin configuration!")
            return None

        if self.rule['event_type'] == Event.EVENT_TYPE:
            event = Event()
        elif self.rule['event_type'] == EventOS.EVENT_TYPE:
            event = EventOS()
        elif self.rule['event_type'] == EventMac.EVENT_TYPE:
            event = EventMac()
        elif self.rule['event_type'] == EventService.EVENT_TYPE:
            event = EventService()
        elif self.rule['event_type'] == EventHids.EVENT_TYPE:
            event = EventHids()
        else:
            logger.error("Bad event_type (%s) in rule (%s)" % \
                (self.rule["event_type"], self.name))
            return None

        for key, value in self.rule.iteritems():
            if key not in ["regexp", "precheck"]:
                event[key] = self.plugin.get_replace_value(
                    value, self.groups, self._replace_assessment[key])

        # if log field is present in the plugin,
        #   use it as a custom log field          (event['log'])
        # else,
        #   use original event has log attribute  (self.log)
        if self.log and not event['log']:
            if self._unicode:
                event['log'] = self.log.encode('utf-8')
            else:
                event['log'] = self.log

        return event
Пример #20
0
    def create_new_event(self, event_info):
        print(event_info)
        event_info_list = event_info.split(":")
        timestamp = event_info_list[0]
        event_type = event_info_list[1]

        if event_type == 'ADD_NODE':
            print("The event type is Add Node")
            node_id = event_info_list[2]
            subscription_list = event_info_list[3].split(",")
            connected_node_list = event_info_list[4].split(",")
            connected_node_cost_list = event_info_list[5].split(",")
            new_Event = Event(timestamp, event_type, node_id, subscription_list, connected_node_list, connected_node_cost_list, None, None)

        elif event_type == 'DELETE_NODE':
            print("The event type is Delete Node")
            node_id = event_info_list[2]
            new_Event = Event(timestamp, event_type, node_id, None, None, None, None, None)

        elif event_type == 'SEND_MESSAGE':
            print("The event type is Send Message")
            node_id = event_info_list[2]
            message = event_info_list[3]
            message_topic = event_info_list[4]
            new_Event = Event(timestamp, event_type, node_id, None, None, None, message, message_topic)

        elif event_type == 'RECEIVE_MESSAGE':
            print("The event type is Receive Message")
            node_id = event_info_list[2]
            new_Event = Event(timestamp, event_type, node_id, None, None, None, None, None)

        elif event_type == 'ADD_SUBSCRIPTION':
            print("The event type is Add Subscription")
            node_id = event_info_list[2]
            subscription_list = event_info_list[3].split(",")
            new_Event = Event(timestamp, event_type, node_id, subscription_list, None, None, None, None)

        elif event_type == 'DELETE_SUBSCRIPTION':
            print("The event type is Delete Subscription")
            node_id = event_info_list[2]
            subscription_list = event_info_list[3].split(",")
            new_Event = Event(timestamp, event_type, node_id, subscription_list, None, None, None, None)

        self.event_list.append(new_Event)                          # Add to the event list
Пример #21
0
    def test_addPause2(self):
        EM.events = []
        TM.schlafenszeit = Zeit(23, 0)
        EM.mittagspause = Event(Zeit(0, 0), Zeit(0, 0))

        event1 = Event(Zeit(11, 30), Zeit(15, 00))
        event2 = Event(Zeit(16, 30), Zeit(22, 00))

        EM.addEvent(event1)
        EM.addEvent(event2)

        lsg1 = Event(Zeit(11, 30), Zeit(13, 00))
        pause = Event(Zeit(13, 0), Zeit(15, 0))
        lsg2 = Event(Zeit(15, 0), Zeit(17, 00))
        lsg3 = Event(Zeit(17, 00), Zeit(22, 30))
        EM.addPause(Zeit(13, 00), Zeit(2, 0))

        self.assertEqual(str(event1), str(lsg1))
        self.assertEqual(str(EM.findeEvent(Zeit(13, 5))), str(pause))
        self.assertTrue(EM.findeEvent(Zeit(13, 5)).istPause)
        self.assertEqual(str(EM.findeEvent(Zeit(15, 20))), str(lsg2))
        self.assertEqual(str(event2), str(lsg3))
Пример #22
0
 def create_event_yandexafishatheater_theater_beshenyedengi(
         start_time=4697604000, finish_time=4697604000, duplicate_id=None):
     event = Event()
     event.source = "YandexAfishaTheater"
     event.title = "Бешеные деньги"
     event.description = "В главной роли Светлана Немоляева"
     event.url = "https://afisha.yandex.ru/moscow/theatre_show/beshenye-dengi-teatr-im-maiakovskogo"
     event.categories = {
         "theatre", "theatre_show", "nearest-events", "comedy",
         "season-premiere", "top-persons", "hitprodazh-badge",
         "newyear-vacations", "theatre-feedback", "family-theatre",
         "traditional-theatre", "theater"
     }
     event.image = "https://avatars.mds.yandex.net/get-afishanew/21422/5543036bb12f14c5b8ac13e180071c83/s270x135"
     event.start_time = start_time
     event.finish_time = finish_time
     event.join_anytime = False
     event.duplicate_id = duplicate_id
     event.source_rating_value = 9.1
     event.source_rating_count = 166
     event.status = "active"
     event.price_min = 400
     event.price_max = 6000
     return event
Пример #23
0
def get_destination(m):
    global d_longitude
    global d_latitude
    d_longitude = m.location.longitude
    d_latitude = m.location.latitude
    coordinates = {
        "o_longitude": o_longitude,
        "o_latitude": o_latitude,
        "d_longitude": d_longitude,
        "d_latitude": d_latitude
    }
    prices = get_price(coordinates)
    sevent = Event(m.chat.id, o_latitude, o_longitude, d_latitude, d_longitude,
                   prices)
    data_handler = DataHandler()
    data_handler.add_event(sevent)
    markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
    itembtnmenu = types.KeyboardButton('🔙')
    markup.row(itembtnmenu)
    bot.send_message(
        m.chat.id,
        'Your desired travel would cost you:\nTAPSI: {}\nSNAPP: {}'.format(
            prices['TAPSI'], prices['SNAPP']),
        reply_markup=markup)
Пример #24
0
    def RewireNode(self, node_id, old_parent, new_parent):
        """
		Notifies the logger of a rewire that happened in the network

		:param node_id: ip6 of the node that has rewired
		:param old_parent: ip6 of the old parent
		:param new_parent: ip6 of the new parent
		:return:
		"""
        node_id = str(node_id)
        old_parent = str(old_parent)
        new_parent = str(new_parent)
        if self.Logger is not None:
            self.EventId += 1
            logg.debug("Sending RewireNode to logger, EventID: " +
                       str(self.EventId))
            # self.Logger.send_multipart([self.Name.encode(), pickle.dumps({
            # 	"EventId"	: self.EventId,
            # 	"SubjectId"	: 2,
            # 	"InfoString": json.dumps({"node_id" : node_id, "old_parent" : old_parent, "new_parent" : new_parent})
            # })])
            self.Logger.send_multipart([
                self.Name.encode(),
                pickle.dumps(
                    Event(
                        self.EventId, 2, time.time(),
                        json.dumps({
                            "node_id": str(node_id),
                            "old_parent": str(old_parent),
                            "new_parent": str(new_parent)
                        })))
            ])
        if self.Active is not None:
            logg.debug("Sending Rewire to the Active")
            self.g.attach_child(node_id, new_parent)
            self.DumpDotData()
Пример #25
0
def listHostingEventsFor(user):
    """
    List all events of a given user, where the user was the host.
    """

    events = []
    with connection:
        log.info("list all hosting events for '" + user.lower() + "'")
        cur = connection.cursor()
        cur.execute('SELECT ID, date, amount, participants, comment, status FROM splitpot_events WHERE splitpot_events.owner = ?'
                    , [user.lower()])
        result = cur.fetchall()
        for curEvent in result:
            events.append(Event(
                id=curEvent[0],
                owner=str(user),
                date=datetime.datetime.strptime(curEvent[1],
                        DATEFORMAT),
                amount=curEvent[2],
                participants=json.loads(curEvent[3]),
                comment=curEvent[4],
                status=curEvent[5],
                ))
    return events
Пример #26
0
    def add_event(self, left, middle, right, events, beachline_y):
        '''
        funckja odpowiada za dodanie zdarzenia (zdarzenie kołowe) do struktury zdarzeń (kolejki priorytetowej).
        Zdarzenie nie może być fałszywym alarmem, więc sprawdzamy to w is_valid
        :param left: lewy łuk
        :param middle: środkowy łuk
        :param right: prawy łuk
        :param events: struktura zdarzeń (kolejka priorytetowa)
        :param beachline_y: linia brzegowa (drzewo czerowono czarne, wzbogacone)
        '''

        y, convergence_point = self.metric.compute_convergence_point(
            left.site.point, middle.site.point, right.site.point)

        is_below_broom = y <= beachline_y

        left_point_is_moving_right = left.site.point[1] < middle.site.point[1]
        right_point_is_moving_right = middle.site.point[1] < right.site.point[1]

        left_initial_x = left.site.point[
            0] if left_point_is_moving_right else middle.site.point[0]
        right_initial_x = middle.site.point[
            0] if right_point_is_moving_right else right.site.point[0]

        is_valid = ((left_point_is_moving_right and left_initial_x < convergence_point[0]) or
                    ((not left_point_is_moving_right) and left_initial_x > convergence_point[0])) and \
                   ((right_point_is_moving_right and right_initial_x < convergence_point[0]) or
                    ((not right_point_is_moving_right) and right_initial_x > convergence_point[0]))

        if is_valid and is_below_broom:
            event = Event(y,
                          EventType.circle,
                          point=convergence_point,
                          arc=middle)
            middle.event = event
            events.put(event)
Пример #27
0
    def select(zeit, exakt=False):
        from TimeManager import TimeManager
        from EventManager import EventManager
        from Event import Event
        from Zeit import Zeit

        if exakt:
            genauigkeit = Zeit(0, 0, None)
        else:
            genauigkeit = TimeManager.genauigkeit
        gefundeneZeit = TimeManager.findeZeit(zeit, genauigkeit)
        if gefundeneZeit is not None:
            gefundeneZeit.zeichneMarkiert()
            ScreenManager.ausgewaehlt = gefundeneZeit
            ScreenManager.ausgewaehlt.fokusiere()
            return
        event = EventManager.findeEvent(zeit, genauigkeit)
        if event is None:
            zeit = zeit.runde()
            # ändere das Datum des neuen Events auf das Datum von akutellesDatum im TimeManager
            #zeit.datum = TimeManager.aktuellesDatum.datum
            if TimeManager.aufstehzeit <= zeit < TimeManager.schlafenszeit:
                neuesEvent = EventManager.addEvent(
                    Event(zeit, zeit + EventManager.eventLaenge))
                ScreenManager.ausgewaehlt = neuesEvent
            else:
                return
        else:
            if zeit.circa(event.startzeit, genauigkeit):
                ScreenManager.ausgewaehlt = event.startzeit
            elif zeit.circa(event.endzeit, genauigkeit):
                ScreenManager.ausgewaehlt = event.endzeit
            else:
                ScreenManager.ausgewaehlt = event
        ScreenManager.ausgewaehlt.zeichneMarkiert()
        ScreenManager.ausgewaehlt.fokusiere()
Пример #28
0
def FindEvents():
    if len(FullEventList) == 0:
        current_folder = os.path.realpath(
            os.path.abspath(
                os.path.split(inspect.getfile(inspect.currentframe()))[0]))
        chromedriver = os.path.join(current_folder, "chromedriver")

        options = Options()
        options.add_argument('--ignore-certificate-errors')
        options.add_argument('--incognito')
        options.add_argument('--headless')
        driver = webdriver.Chrome(executable_path=chromedriver,
                                  options=options)
        driver.get("https://www.sandiego.org/explore/events.aspx")
        LoadMore = driver.find_element_by_xpath(
            '//button[@class="submit-button__secondary load-more"]')
        LoadMore.click()
        time.sleep(0.3)
        LoadMore.click()
        time.sleep(0.3)
        soup = BeautifulSoup(driver.page_source, 'lxml')
        #print(soup)
        eventlist = []
        for links in soup.find_all('section', class_="result"):
            #print(links.find('div', class_="result__tag").get_text())
            E = Event(
                links.find('a', class_="result__title-link").get_text(),
                links.find('div', class_="result__dates").get_text(),
                "No Location", "Not Know", "Not Know", "not Know",
                links.find('div',
                           class_="result__tag").get_text(), "Not Known",
                links.find('a', class_="result__cta-link").get('href'),
                "Not Filled", "Not Contact", "No DateTime")
            FullEventList.append(E)

        driver.close()
    def construct(self):
        """
        stores Voronoi diagram in self.diagram
        :return: None
        """

        events = Events()

        for s in self.diagram.sites:
            event = Event(s.point[1], EventType.site, site=s, point=s.point)
            events.insert(event)

        not_valid_events = set()

        while not events.empty():
            event = events.pop()

            if event in not_valid_events:
                continue

            if event.type == EventType.site:
                self.handle_site_event(event, not_valid_events, events)
            else:
                self.handle_circle_event(event, not_valid_events, events)
 def __init__(self):
     self.__waitForSync = False
     self.__invalidateCbID = None
     self.__cache = defaultdict(dict)
     self.__personalMissionsHidden = {}
     self.__actionsCache = defaultdict(lambda : defaultdict(dict))
     self.__actions2quests = {}
     self.__quests2actions = {}
     self.__questsDossierBonuses = defaultdict(set)
     self.__compensations = {}
     self.__personalMissions = PersonalMissionsCache()
     self.__questsProgress = QuestsProgressRequester()
     self.__em = EventManager()
     self.__prefetcher = Prefetcher(self)
     self.onSyncStarted = Event(self.__em)
     self.onSyncCompleted = Event(self.__em)
     self.onProgressUpdated = Event(self.__em)
     self.onMissionVisited = Event(self.__em)
     self.onEventsVisited = Event(self.__em)
     self.onProfileVisited = Event(self.__em)
     self.onPersonalQuestsVisited = Event(self.__em)
     self.__lockedQuestIds = {}
     return