def test_add_new_region_to_existing_deal_and_calculate_loss(self): """ Tests that a new region can be added dynamically to an existing deal for an uncovered event and the loss can be calculated on the fly """ peril = 'fire' region = 'Porto' damage = 400 event = Event(peril, region, damage, deals) if not event.deals_list: ManageDeals.add_new_deal(250, 250, [ peril, ], [ region, ], deals) peril = 'fire' region = 'Lisbon' damage = 700 event = Event(peril, region, damage, deals) if not event.deals_list: ManageDeals.add_region_to_deal('deal4', region, deals) event.get_applicable_deals(deals) loss = event.total_loss() assert loss == 250
def test_calculate_loss_event3(self): """ Tests that event3 causes a loss of 250 """ event = Event('flood', 'Florida', 750, deals) loss = event.total_loss() assert loss == 250
def test_calculate_loss_event1(self): """ Tests that event1 causes a loss of 500 """ event = Event('earthquake', 'California', 1000, deals) loss = event.total_loss() assert loss == 500
def test_calculate_loss_event4(self): """ Tests that event4 causes a loss of 1250. Tests when an event affects more than 1 deal. """ event = Event('hurricane', 'Florida', 2000, deals) loss = event.total_loss() assert loss == 1250
def test_calculate_loss_event2(self): """ Tests that event2 causes a loss of 250 """ event = Event('flood', 'Louisiana', 500, deals) loss = event.total_loss() assert loss == 250
async def set_volume(self, volume): self.core.bus.dispatch(Event("cec.setting_volume", volume)) running = True if self._target is not None else False self._target = volume if not running: await self.out_queue.put( Command(CECCommand.get_volume, self._approach_volume) )
def test_get_applicable_deals_returns_list_with_1_deal(self): event = Event('flood', 'Louisiana', 500, deals) event.deals_list = [] event.get_applicable_deals(deals) self.assertAlmostEqual(event.deals_list, [{ 'retention': 250, 'limit': 250, 'perils': ['hurricane', 'flood'], 'regions': ['Florida', 'Louisiana'] }])
async def prepare(self): await self.websocket.prepare(self.request) self.is_open = True self.core.bus.dispatch( Event( NEW_WEBSOCKET_CONNECTION, { "id": self.id, "type": self.connection_type, "connection": self }, )) self.core.add_job(self.reader) await self.writer()
def test_get_applicable_deals_returns_list_with_2_deal(self): event = Event('hurricane', 'Florida', 2000, deals) event.deals_list = [] event.get_applicable_deals(deals) self._baseAssertEqual(event.deals_list, [{ 'regions': ['Florida', 'Louisiana'], 'perils': ['hurricane', 'flood'], 'limit': 250, 'retention': 250 }, { 'regions': ['Florida'], 'perils': ['hurricane'], 'limit': 3000, 'retention': 1000 }])
async def dispatch_event_service(self, content: Any, context: Context, event_type: str = ""): """ dispatch an event on the event bus :param content: :param context: :param event_type: :return: """ if context.authorize(BUS, DISPATCH_EVENT): event = Event(event_type, content, context) self.dispatch(event) else: raise NotAuthorizedError( f"user {context.user} is not allowed to access the bus", context, BUS)
async def cio(self): while True: with suppress(Exception): _input = await ainput() args = _input.split(" ") if args[0] in ["run", "r"]: if len(args) == 4: config = ast.literal_eval(args[3]) else: config = {} self.io.run_service(args[1], ast.literal_eval(args[2]), config, Context.admin()) elif args[0] in ["set", "s"]: self.registry.call_method_d(f"{args[1]}.set", ast.literal_eval(args[2]), Context.admin()) elif args[0] in ["dispatch", "d"]: self.bus.dispatch(Event(args[1], ast.literal_eval(args[2])))
def dispatch_state_change_event( self, entity: Entity, component: str, new_state: Any, executing_context: Context, context: Context = None, ): self.core.bus.dispatch( Event( event_type=ENTITY_STATE_CHANGED, event_content={ "entity": entity, "component": component, "new_state": new_state, "component_type": entity.components[component].type, "executing_context": executing_context, }, context=context, ))
def disconnected(self, e): self.instance.close() if self.reconnect and not self.silent: LOGGER.warning( f"Serial port {self.port} disconnected. Exception: {e}. Trying to reconnect in {self.reconnect_time}" ) elif not self.silent: LOGGER.warning( f"Serial port {self.port} disconnected. Exception: {e}.") self.core.bus.dispatch( Event(constants.Events.port_disconnected, { "port": self.port, "name": self.name, "exception": e })) if self.reconnect: self.core.timer.scheduled_call(self.setup, delay=self.reconnect_time)
async def manager(self, reader, writer: StreamWriter): self.core.bus.dispatch( Event(event_type="cec.reconnected", event_content=None, context=None) ) while True: try: done, pending = await asyncio.wait( [self.out_queue.get(), reader.readline(), self._close_event.wait()], return_when=asyncio.FIRST_COMPLETED, loop=self.core.event_loop, ) except Exception as e: print(e) break try: gathered = asyncio.gather(*pending) gathered.cancel() await gathered except CancelledError: pass result = done.pop().result() if type(result) is bool: writer.close() await writer.wait_closed() self._closed_event.set() break if type(result) is Command: if type(result.command.value) is list: for fragment in result.command.value: writer.write(fragment.encode()) else: writer.write(result.command.value.encode()) await writer.drain() if result.callback: msg = await reader.readline() await result.callback(msg.decode()) else: pass
async def _approach_volume(self, new_volume): if str(new_volume).startswith("51:7a:"): self.volume = calculate_volume(new_volume) elif type(new_volume) is str: await self.out_queue.put( Command(CECCommand.get_volume, self._approach_volume) ) return await asyncio.sleep(0.2) if self._target < self.volume: await self.out_queue.put( Command(CECCommand.decrease_volume, self._approach_volume) ) elif self._target > self.volume: await self.out_queue.put( Command(CECCommand.increase_volume, self._approach_volume) ) else: self._target = None self.core.bus.dispatch(Event("cec.set_volume", self.volume))
async def setup(self, time=None): try: self.instance.close() except: pass try: self.instance.open() except Exception as e: if not self.silent: LOGGER.warning( f"couldn't open serial port {self.port}! Exceptions {e}") if self.reconnect: self.core.timer.scheduled_call(self.setup, delay=self.reconnect_time) return self.__reader = self.core.add_job(self._reader) self.__writer = self.core.add_job(self._writer) self.core.bus.dispatch( Event(constants.Events.port_connected, { 'port': self.port, 'name': self.name }))
async def gql_dispatch_event(self, *_, eventType="", eventContent=None): self.core.bus.dispatch( Event(event_type=eventType, event_content=eventContent))
def test_total_loss_when_damage_higher_then_deal3_limit_and_deal2_limit( self): event = Event('hurricane', 'Florida', 5000, deals) self.assertTrue(event.total_loss() == 3250)
def playback_device_change(device: asp.Device): return Event(event_type=EVENT_PLAYBACK_DEVICE_CHANGE, event_content=device)
def track_change_event(track: asp.track.FullTrack): return Event(event_type=EVENT_TRACK_CHANGE, event_content=track)
def playback_started_event(track: asp.track.FullTrack): return Event(event_type=EVENT_PLAYBACK_STARTED, event_content=track)
def playback_resumed_event(track: asp.track.FullTrack): return Event(event_type=EVENT_PLAYBACK_RESUMED, event_content=track)
def playback_stopped_event(track: Optional[asp.track.FullTrack]): return Event(event_type=EVENT_PLAYBACK_STOPPED, event_content=track)
def test_get_applicable_deals_returns_empty_list_when_there_is_no_deal_for_event( self): event = Event('hurricane', 'Minnesota', 2000, deals) event.deals_list = ['dummy data'] event.get_applicable_deals(deals) self._baseAssertEqual(event.deals_list, [])
def test_total_loss_returns_0_when_no_deal_exists_for_event(self): event = Event('hurricane', 'Minnesota', 2000, deals) event.deals_list = [] self.assertTrue(event.total_loss() == 0)
def test_total_loss_returns_0_when_damage_lower_then_retention(self): event = Event('flood', 'Louisiana', 100, deals) self.assertTrue(event.total_loss() == 0)
def test_total_loss_lower_then_limit(self): event = Event('flood', 'Louisiana', 450, deals) self.assertTrue(event.total_loss() == 200)
def test_total_loss_limited_by_limit(self): event = Event('flood', 'Louisiana', 450000, deals) self.assertTrue(event.total_loss() == 250)
def test_total_loss_returns_0_with_several_deals_when_damage_lower_the_retetion( self): event = Event('hurricane', 'Florida', 50, deals) self.assertTrue(event.total_loss() == 0)
def created_event(entity: Entity, user: User): return Event( event_type=ENTITY_CREATED, event_content=entity, context=Context(user=user, remote=False), )