async def test_switched_host(hass: HomeAssistantType): """Test cast device listens for changed hosts and disconnects old cast.""" info = get_fake_chromecast_info() full_info = attr.evolve(info, model_name='google home', friendly_name='Speaker', uuid=FakeUUID) with patch('pychromecast.dial.get_device_status', return_value=full_info): chromecast, _ = await async_setup_media_player_cast(hass, full_info) chromecast2 = get_fake_chromecast(info) with patch('pychromecast._get_chromecast_from_host', return_value=chromecast2) as get_chromecast: async_dispatcher_send(hass, cast.SIGNAL_CAST_DISCOVERED, full_info) await hass.async_block_till_done() assert get_chromecast.call_count == 0 changed = attr.evolve(full_info, friendly_name='Speaker 2') async_dispatcher_send(hass, cast.SIGNAL_CAST_DISCOVERED, changed) await hass.async_block_till_done() assert get_chromecast.call_count == 0 changed = attr.evolve(changed, host='host2') async_dispatcher_send(hass, cast.SIGNAL_CAST_DISCOVERED, changed) await hass.async_block_till_done() assert get_chromecast.call_count == 1 assert chromecast.disconnect.call_count == 1
def union1(p: Union[A, B]): attr.fields(<warning descr="'attr.fields' method should be called on attrs types">p</warning>) attr.fields_dict(<warning descr="'attr.fields_dict' method should be called on attrs types">p</warning>) attr.asdict(p) attr.astuple(p) attr.assoc(p) attr.evolve(p)
def union2(p: Union[Type[A], Type[B]]): attr.fields(p) attr.fields_dict(p) attr.asdict(<warning descr="'attr.asdict' method should be called on attrs instances">p</warning>) attr.astuple(<warning descr="'attr.astuple' method should be called on attrs instances">p</warning>) attr.assoc(<warning descr="'attr.assoc' method should be called on attrs instances">p</warning>) attr.evolve(<warning descr="'attr.evolve' method should be called on attrs instances">p</warning>)
def structural(p): print(len(p)) attr.fields(p) attr.fields_dict(p) attr.asdict(p) attr.astuple(p) attr.assoc(p) attr.evolve(p)
def test_unknown(self, C): """ Wanting to change an unknown attribute raises an AttrsAttributeNotFoundError. """ # No generated class will have a four letter attribute. with pytest.raises(TypeError) as e: evolve(C(), aaaa=2) expected = "__init__() got an unexpected keyword argument 'aaaa'" assert (expected,) == e.value.args
def test_can_add_authorizers_to_dependencies(lambda_function): auth1 = evolve(lambda_function, resource_name='auth1') auth2 = evolve(lambda_function, resource_name='auth2') rest_api = models.RestAPI( resource_name='rest_api', swagger_doc={'swagger': '2.0'}, api_gateway_stage='api', lambda_function=lambda_function, authorizers=[auth1, auth2], ) assert rest_api.dependencies() == [lambda_function, auth1, auth2]
def test_validator_failure(self): """ TypeError isn't swallowed when validation fails within evolve. """ @attributes class C(object): a = attr(validator=instance_of(int)) with pytest.raises(TypeError) as e: evolve(C(a=1), a="some string") m = e.value.args[0] assert m.startswith("'a' must be <{type} 'int'>".format(type=TYPE))
def test_private(self): """ evolve() acts as `__init__` with regards to private attributes. """ @attributes class C(object): _a = attr() assert evolve(C(1), a=2)._a == 2 with pytest.raises(TypeError): evolve(C(1), _a=2) with pytest.raises(TypeError): evolve(C(1), a=3, _a=2)
def _async_update_device(self, device_id, *, config_entry_id=_UNDEF, remove_config_entry_id=_UNDEF, hub_device_id=_UNDEF): """Update device attributes.""" old = self.devices[device_id] changes = {} config_entries = old.config_entries if (config_entry_id is not _UNDEF and config_entry_id not in old.config_entries): config_entries = old.config_entries | {config_entry_id} if (remove_config_entry_id is not _UNDEF and remove_config_entry_id in config_entries): config_entries = set(config_entries) config_entries.remove(remove_config_entry_id) if config_entries is not old.config_entries: changes['config_entries'] = config_entries if (hub_device_id is not _UNDEF and hub_device_id != old.hub_device_id): changes['hub_device_id'] = hub_device_id if not changes: return old new = self.devices[device_id] = attr.evolve(old, **changes) self.async_schedule_save() return new
def _search_unicode_file(subsequence, sequence_file, search_params, search_class, _chunk_size): if not subsequence: raise ValueError('subsequence must not be empty') CHUNK_SIZE = _chunk_size keep_chars = ( len(subsequence) - 1 + search_class.extra_items_for_chunked_search(subsequence, search_params) ) chunk = sequence_file.read(CHUNK_SIZE) offset = 0 while chunk: for match in search_class.search(subsequence, chunk, search_params): yield attr.evolve(match, start=match.start + offset, end=match.end + offset) n_to_keep = min(keep_chars, len(chunk)) offset += len(chunk) - n_to_keep if n_to_keep: chunk = chunk[-n_to_keep:] + sequence_file.read(CHUNK_SIZE) if len(chunk) == n_to_keep: break else: chunk = sequence_file.read(CHUNK_SIZE)
def remove(self, *types): """ Produce a new checker with the given types forgotten. Arguments: types (~collections.Iterable): the names of the types to remove. Returns: A new `TypeChecker` instance Raises: `jsonschema.exceptions.UndefinedTypeCheck`: if any given type is unknown to this object """ checkers = self._type_checkers for each in types: try: checkers = checkers.remove(each) except KeyError: raise UndefinedTypeCheck(each) return attr.evolve(self, type_checkers=checkers)
def async_update_entity(self, entity_id, *, name=_UNDEF): """Update properties of an entity.""" old = self.entities[entity_id] changes = {} if name is not _UNDEF and name != old.name: changes['name'] = name if not changes: return old new = self.entities[entity_id] = attr.evolve(old, **changes) to_remove = [] for listener_ref in new.update_listeners: listener = listener_ref() if listener is None: to_remove.append(listener) else: try: listener.async_registry_updated(old, new) except Exception: # pylint: disable=broad-except _LOGGER.exception('Error calling update listener') for ref in to_remove: new.update_listeners.remove(ref) self.async_schedule_save() return new
def test_can_update_lambda_function_code(self): function = create_function_resource('function_name') copy_of_function = attr.evolve(function) self.remote_state.declare_resource_exists(copy_of_function) # Now let's change the memory size and ensure we # get an update. function.memory_size = 256 plan = self.determine_plan(function) existing_params = { 'function_name': 'appname-dev-function_name', 'role_arn': 'role:arn', 'zip_contents': mock.ANY, 'runtime': 'python2.7', 'environment_variables': {}, 'tags': {}, 'timeout': 60, } expected_params = dict(memory_size=256, **existing_params) expected = models.APICall( method_name='update_function', params=expected_params, ) self.assert_apicall_equals(plan[0], expected) assert list(self.last_plan.messages.values()) == [ 'Updating lambda function: appname-dev-function_name\n' ]
def remove_many(self, types): """ Remove multiple types from the checkers that this object understands. Arguments: types (~collections.Iterable): An iterable of types to remove. Returns: A new `TypeChecker` instance Raises: `jsonschema.exceptions.UndefinedTypeCheck`: if any of the types are unknown to this object """ checkers = self._type_checkers for each in types: try: checkers = checkers.remove(each) except KeyError: raise UndefinedTypeCheck(each) return attr.evolve(self, type_checkers=checkers)
def test_no_changes(self, C): """ No changes means a verbatim copy. """ i1 = C() i2 = evolve(i1) assert i1 is not i2 assert i1 == i2
def test_non_init_attrs(self): """ evolve() handles `init=False` attributes. """ @attributes class C(object): a = attr() b = attr(init=False, default=0) assert evolve(C(1), a=2).a == 2
def chdir(self, path): """ Return a new executor where the working directory is different. :param path: new path :returns: new executor with a different working directory """ new_shell = self._shell.clone() new_shell.chdir(path) return attr.evolve(self, shell=new_shell)
def _async_update_entity(self, entity_id, *, name=_UNDEF, config_entry_id=_UNDEF, new_entity_id=_UNDEF, device_id=_UNDEF): """Private facing update properties method.""" old = self.entities[entity_id] changes = {} if name is not _UNDEF and name != old.name: changes['name'] = name if (config_entry_id is not _UNDEF and config_entry_id != old.config_entry_id): changes['config_entry_id'] = config_entry_id if (device_id is not _UNDEF and device_id != old.device_id): changes['device_id'] = device_id if new_entity_id is not _UNDEF and new_entity_id != old.entity_id: if self.async_is_registered(new_entity_id): raise ValueError('Entity is already registered') if not valid_entity_id(new_entity_id): raise ValueError('Invalid entity ID') if (split_entity_id(new_entity_id)[0] != split_entity_id(entity_id)[0]): raise ValueError('New entity ID should be same domain') self.entities.pop(entity_id) entity_id = changes['entity_id'] = new_entity_id if not changes: return old new = self.entities[entity_id] = attr.evolve(old, **changes) to_remove = [] for listener_ref in new.update_listeners: listener = listener_ref() if listener is None: to_remove.append(listener) else: try: listener.async_registry_updated(old, new) except Exception: # pylint: disable=broad-except _LOGGER.exception('Error calling update listener') for ref in to_remove: new.update_listeners.remove(ref) self.async_schedule_save() return new
def patch_env(self, **kwargs): """ Return a new executor where the environment is patched with the given attributes :param kwargs: new environment variables :returns: new executor with a shell with a patched environment. """ new_shell = self._shell.clone() for key, value in kwargs.items(): new_shell.setenv(key, value) return attr.evolve(self, shell=new_shell)
async def test_entity_media_states(hass: HomeAssistantType): """Test various entity media states.""" info = get_fake_chromecast_info() full_info = attr.evolve(info, model_name='google home', friendly_name='Speaker', uuid=FakeUUID) with patch('pychromecast.dial.get_device_status', return_value=full_info): chromecast, entity = await async_setup_media_player_cast(hass, info) entity._available = True entity.schedule_update_ha_state() await hass.async_block_till_done() state = hass.states.get('media_player.speaker') assert state is not None assert state.name == 'Speaker' assert state.state == 'unknown' assert entity.unique_id == full_info.uuid media_status = MagicMock(images=None) media_status.player_is_playing = True entity.new_media_status(media_status) await hass.async_block_till_done() state = hass.states.get('media_player.speaker') assert state.state == 'playing' media_status.player_is_playing = False media_status.player_is_paused = True entity.new_media_status(media_status) await hass.async_block_till_done() state = hass.states.get('media_player.speaker') assert state.state == 'paused' media_status.player_is_paused = False media_status.player_is_idle = True entity.new_media_status(media_status) await hass.async_block_till_done() state = hass.states.get('media_player.speaker') assert state.state == 'idle' media_status.player_is_idle = False chromecast.is_idle = True entity.new_media_status(media_status) await hass.async_block_till_done() state = hass.states.get('media_player.speaker') assert state.state == 'off' chromecast.is_idle = False entity.new_media_status(media_status) await hass.async_block_till_done() state = hass.states.get('media_player.speaker') assert state.state == 'unknown'
def replace_rank(*cards, from_=(rAno, rAlo), to=rAhi): """ >>> alo = evolve(cAh, rank=rAlo) >>> ahi = evolve(cAs, rank=rAhi) >>> check = replace_rank(alo, ahi, from_=(rAhi, rAlo), to=rAno) >>> expect = {cAh, cAs} >>> check == expect True """ return {evolve(c, rank=to) if c.rank in from_ else c for c in cards}
def _async_update_device(self, device_id, *, add_config_entry_id=_UNDEF, remove_config_entry_id=_UNDEF, merge_connections=_UNDEF, merge_identifiers=_UNDEF, manufacturer=_UNDEF, model=_UNDEF, name=_UNDEF, sw_version=_UNDEF, hub_device_id=_UNDEF): """Update device attributes.""" old = self.devices[device_id] changes = {} config_entries = old.config_entries if (add_config_entry_id is not _UNDEF and add_config_entry_id not in old.config_entries): config_entries = old.config_entries | {add_config_entry_id} if (remove_config_entry_id is not _UNDEF and remove_config_entry_id in config_entries): config_entries = config_entries - {remove_config_entry_id} if config_entries is not old.config_entries: changes['config_entries'] = config_entries for attr_name, value in ( ('connections', merge_connections), ('identifiers', merge_identifiers), ): old_value = getattr(old, attr_name) # If not undefined, check if `value` contains new items. if value is not _UNDEF and not value.issubset(old_value): changes[attr_name] = old_value | value for attr_name, value in ( ('manufacturer', manufacturer), ('model', model), ('name', name), ('sw_version', sw_version), ('hub_device_id', hub_device_id), ): if value is not _UNDEF and value != getattr(old, attr_name): changes[attr_name] = value if not changes: return old new = self.devices[device_id] = attr.evolve(old, **changes) self.async_schedule_save() return new
def test_validation_after_evolve_call(): smaj = 1.5 smin = 1. g1 = Gaussian2dParams(x_centre=0, y_centre=0, amplitude=1, semimajor=smaj, semiminor=smin, theta=0., ) with pytest.raises(ValueError): g2 = attr.evolve(g1, semimajor=smin - 0.1)
def test_empty(self, slots, frozen): """ Empty classes without changes get copied. """ @attributes(slots=slots, frozen=frozen) class C(object): pass i1 = C() i2 = evolve(i1) assert i1 is not i2 assert i1 == i2
def test_correlation_coefficient(): smaj = 1.5 smin = 1. g1 = Gaussian2dParams(x_centre=0, y_centre=0, amplitude=1, semimajor=smaj, semiminor=smin, theta=0., ) assert g1.correlation == 0 cov = np.array([[smaj * smaj, 0], [0, smin * smin]]) assert_equal(g1.covariance, cov) cov_rotated = np.array([[smin * smin, 0], [0, smaj * smaj]]) g1 = attr.evolve(g1, theta=np.pi / 2) assert_allclose(g1.covariance, cov_rotated, atol=1e-10) smaj = 1e5 g2 = Gaussian2dParams(x_centre=0, y_centre=0, amplitude=1, semimajor=smaj, semiminor=smin, theta=0., ) assert g2.correlation == 0 g2 = attr.evolve(g2, theta=np.pi / 4) # print() # print(g2.correlation) # print(1.0 - g2.correlation) assert g2.correlation == approx(1.0, rel=1e-7) g2 = attr.evolve(g2, theta=-np.pi / 4) assert g2.correlation == approx(-1.0, rel=1e-7)
def test_approx_equality(): init_pars = dict(x_centre=48.24, y_centre=52.66, amplitude=42., semimajor=1.5, semiminor=1.4, theta=1.1, ) g1 = Gaussian2dParams(**init_pars) g2 = Gaussian2dParams(**init_pars) assert g1 == g2 g2 = attr.evolve(g2, y_centre=g2.y_centre + 5e-9, amplitude=g2.amplitude - 5e-9, ) assert g1 != g2 assert g2.approx_equal_to(g1) g2 = attr.evolve(g2, theta=g2.theta + g2.theta * 1e-4) # It appears that the correlation sensitivity matches reasonably well # to the order-of-change to theta (at least for these semimajor/minor): assert g2.comparable_params == approx(g1.comparable_params, rel=2e-4) assert g2.comparable_params != approx(g1.comparable_params, rel=1e-4)
def test_change(self, C, data): """ Changes work. """ # Take the first attribute, and change it. assume(fields(C)) # Skip classes with no attributes. field_names = [a.name for a in fields(C)] original = C() chosen_names = data.draw(st.sets(st.sampled_from(field_names))) # We pay special attention to private attributes, they should behave # like in `__init__`. change_dict = {name.replace('_', ''): data.draw(st.integers()) for name in chosen_names} changed = evolve(original, **change_dict) for name in chosen_names: assert getattr(changed, name) == change_dict[name.replace('_', '')]
def async_update(self, area_id: str, name: str) -> AreaEntry: """Update name of area.""" old = self.areas[area_id] changes = {} if name == old.name: return old if self._async_is_registered(name): raise ValueError('Name is already in use') changes['name'] = name new = self.areas[area_id] = attr.evolve(old, **changes) self.async_schedule_save() return new
def redefine_many(self, definitions=()): """ Produce a new checker with the given types redefined. Arguments: definitions (dict): A dictionary mapping types to their checking functions. Returns: A new `TypeChecker` instance. """ return attr.evolve( self, type_checkers=self._type_checkers.update(definitions), )
def async_update(self, device) -> ZhaDeviceEntry: """Update name of ZhaDeviceEntry.""" ieee_str = str(device.ieee) old = self.devices[ieee_str] changes = {} if device.power_source != old.power_source: changes['power_source'] = device.power_source if device.manufacturer_code != old.manufacturer_code: changes['manufacturer_code'] = device.manufacturer_code changes['last_seen'] = device.last_seen new = self.devices[ieee_str] = attr.evolve(old, **changes) self.async_schedule_save() return new
def set_id(panel): return panel if panel.id else attr.evolve(panel, id=next(auto_ids))
def set_event_probs(self, **running_event_probs): self.running_event_probabilities = attr.evolve( self.running_event_probabilities, **running_event_probs)
def main( options: optparse.Values, *, term: Optional[Terminal] = None, render_header: bool = True, render_footer: bool = True, width: Optional[int] = None, wait_on_actions: Optional[float] = None, ) -> None: data = pg_connect( options, password=os.environ.get("PGPASSWORD"), service=os.environ.get("PGSERVICE"), min_duration=options.minduration, ) hostname = socket.gethostname() fs_blocksize = options.blocksize host = types.Host( data.pg_version, hostname, options.username, options.host, options.port, options.dbname, ) is_local = data.pg_is_local() and data.pg_is_local_access() skip_sizes = options.nodbsize pg_db_info = data.pg_get_db_info(None, using_rds=options.rds, skip_sizes=options.nodbsize) flag = types.Flag.from_options(is_local=is_local, **vars(options)) ui = types.UI.make( flag=flag, min_duration=options.minduration, duration_mode=int(options.durationmode), verbose_mode=int(options.verbosemode), max_db_length=min(max(int(pg_db_info["max_length"]), 8), 16), ) if term is None: # Used in tests. term = Terminal() key, in_help = None, False sys_procs: Dict[int, types.SystemProcess] = {} pg_procs = types.SelectableProcesses([]) activity_stats: types.ActivityStats msg_pile = utils.MessagePile(2) with term.fullscreen(), term.cbreak(), term.hidden_cursor(): while True: if key == keys.HELP: in_help = True elif in_help and key is not None: in_help, key = False, None elif key == keys.EXIT: break elif not ui.interactive() and key == keys.SPACE: ui = ui.toggle_pause() elif options.nodbsize and key == keys.REFRESH_DB_SIZE: skip_sizes = False elif key is not None: if keys.is_process_next(key): pg_procs.focus_next() ui.start_interactive() elif keys.is_process_prev(key): pg_procs.focus_prev() ui.start_interactive() elif key == keys.SPACE: pg_procs.toggle_pin_focused() elif key.name == keys.CANCEL_SELECTION: pg_procs.reset() ui.end_interactive() elif pg_procs.selected and key in ( keys.PROCESS_CANCEL, keys.PROCESS_KILL, ): action, color = { keys.PROCESS_CANCEL: ("cancel", "yellow"), keys.PROCESS_KILL: ("terminate", "red"), }[key] action_formatter = getattr(term, color) pids = pg_procs.selected if len(pids) > 1: ptitle = f"processes {', '.join((str(p) for p in pids))}" else: ptitle = f"process {pids[0]}" with term.location(x=0, y=term.height // 3): print( widgets.boxed( term, f"Confirm {action_formatter(action)} action on {ptitle}? (y/n)", border_color=color, center=True, width=width, ), end="", ) confirm_key = term.inkey(timeout=None) if confirm_key.lower() == "y": if action == "cancel": for pid in pids: data.pg_cancel_backend(pid) msg_pile.send( action_formatter( f"{ptitle.capitalize()} cancelled")) elif action == "terminate": for pid in pids: data.pg_terminate_backend(pid) msg_pile.send( action_formatter( f"{ptitle.capitalize()} terminated")) pg_procs.reset() ui.end_interactive() if wait_on_actions: # Used in tests. time.sleep(wait_on_actions) else: pg_procs.reset() ui.end_interactive() changes = { "duration_mode": handlers.duration_mode(key, ui.duration_mode), "verbose_mode": handlers.verbose_mode(key, ui.verbose_mode), } if key in (keys.REFRESH_TIME_INCREASE, keys.REFRESH_TIME_DECREASE): changes["refresh_time"] = handlers.refresh_time( key, ui.refresh_time) query_mode = handlers.query_mode(key) if query_mode is not None: changes["query_mode"] = query_mode else: query_mode = ui.query_mode sort_key = handlers.sort_key_for(key, query_mode, flag) if sort_key is not None: changes["sort_key"] = sort_key ui = ui.evolve(**changes) if in_help: print(term.clear + term.home, end="") views.help( term, __version__, is_local, lines_counter=views.line_counter(term.height), ) else: pg_db_info = data.pg_get_db_info(pg_db_info, using_rds=options.rds, skip_sizes=skip_sizes) if options.nodbsize and not skip_sizes: skip_sizes = True dbinfo = types.DBInfo( total_size=int(pg_db_info["total_size"]), size_ev=int(pg_db_info["size_ev"]), ) tps = int(pg_db_info["tps"]) active_connections = data.pg_get_active_connections() memory, swap, load = activities.mem_swap_load() system_info = types.SystemInfo.default(memory=memory, swap=swap, load=load) if not ui.in_pause and not ui.interactive(): if is_local: memory, swap, load = activities.mem_swap_load() system_info = attr.evolve( system_info, memory=memory, swap=swap, load=load, ) if ui.query_mode == types.QueryMode.activities: pg_procs.set_items( data.pg_get_activities(ui.duration_mode)) if is_local: # TODO: Use this logic in waiting and blocking cases. local_pg_procs, io_read, io_write = activities.ps_complete( cast(List[types.RunningProcess], pg_procs.items), sys_procs, fs_blocksize, ) system_info = attr.evolve( system_info, io_read=io_read, io_write=io_write, max_iops=activities.update_max_iops( system_info.max_iops, io_read.count, io_write.count, ), ) pg_procs.set_items(local_pg_procs) else: if ui.query_mode == types.QueryMode.blocking: pg_procs.set_items( data.pg_get_blocking(ui.duration_mode)) elif ui.query_mode == types.QueryMode.waiting: pg_procs.set_items( data.pg_get_waiting(ui.duration_mode)) else: assert False # help type checking activity_stats = ( pg_procs, system_info) if is_local else pg_procs # type: ignore if options.output is not None: with open(options.output, "a") as f: utils.csv_write(f, map(attr.asdict, pg_procs.items)) views.screen( term, ui, host=host, dbinfo=dbinfo, tps=tps, active_connections=active_connections, activity_stats=activity_stats, message=msg_pile.get(), render_header=render_header, render_footer=render_footer, width=width, ) if ui.interactive(): if not pg_procs.pinned: ui.tick_interactive() elif pg_procs.selected: pg_procs.reset() key = term.inkey(timeout=ui.refresh_time) or None
def _async_update_entity( self, entity_id, *, name=_UNDEF, icon=_UNDEF, config_entry_id=_UNDEF, new_entity_id=_UNDEF, device_id=_UNDEF, new_unique_id=_UNDEF, disabled_by=_UNDEF, capabilities=_UNDEF, supported_features=_UNDEF, device_class=_UNDEF, unit_of_measurement=_UNDEF, original_name=_UNDEF, original_icon=_UNDEF, ): """Private facing update properties method.""" old = self.entities[entity_id] changes = {} for attr_name, value in ( ("name", name), ("icon", icon), ("config_entry_id", config_entry_id), ("device_id", device_id), ("disabled_by", disabled_by), ("capabilities", capabilities), ("supported_features", supported_features), ("device_class", device_class), ("unit_of_measurement", unit_of_measurement), ("original_name", original_name), ("original_icon", original_icon), ): if value is not _UNDEF and value != getattr(old, attr_name): changes[attr_name] = value if new_entity_id is not _UNDEF and new_entity_id != old.entity_id: if self.async_is_registered(new_entity_id): raise ValueError("Entity is already registered") if not valid_entity_id(new_entity_id): raise ValueError("Invalid entity ID") if split_entity_id(new_entity_id)[0] != split_entity_id( entity_id)[0]: raise ValueError("New entity ID should be same domain") self.entities.pop(entity_id) entity_id = changes["entity_id"] = new_entity_id if new_unique_id is not _UNDEF: conflict = next( (entity for entity in self.entities.values() if entity.unique_id == new_unique_id and entity.domain == old.domain and entity.platform == old.platform), None, ) if conflict: raise ValueError( f"Unique id '{new_unique_id}' is already in use by " f"'{conflict.entity_id}'") changes["unique_id"] = new_unique_id if not changes: return old new = self.entities[entity_id] = attr.evolve(old, **changes) self.async_schedule_save() data = { "action": "update", "entity_id": entity_id, "changes": list(changes) } if old.entity_id != entity_id: data["old_entity_id"] = old.entity_id self.hass.bus.async_fire(EVENT_ENTITY_REGISTRY_UPDATED, data) return new
def _async_update_entity( self, entity_id: str, *, name: Union[str, None, UndefinedType] = UNDEFINED, icon: Union[str, None, UndefinedType] = UNDEFINED, config_entry_id: Union[str, None, UndefinedType] = UNDEFINED, new_entity_id: Union[str, UndefinedType] = UNDEFINED, device_id: Union[str, None, UndefinedType] = UNDEFINED, area_id: Union[str, None, UndefinedType] = UNDEFINED, new_unique_id: Union[str, UndefinedType] = UNDEFINED, disabled_by: Union[str, None, UndefinedType] = UNDEFINED, capabilities: Union[Dict[str, Any], None, UndefinedType] = UNDEFINED, supported_features: Union[int, UndefinedType] = UNDEFINED, device_class: Union[str, None, UndefinedType] = UNDEFINED, unit_of_measurement: Union[str, None, UndefinedType] = UNDEFINED, original_name: Union[str, None, UndefinedType] = UNDEFINED, original_icon: Union[str, None, UndefinedType] = UNDEFINED, ) -> RegistryEntry: """Private facing update properties method.""" old = self.entities[entity_id] changes = {} for attr_name, value in ( ("name", name), ("icon", icon), ("config_entry_id", config_entry_id), ("device_id", device_id), ("area_id", area_id), ("disabled_by", disabled_by), ("capabilities", capabilities), ("supported_features", supported_features), ("device_class", device_class), ("unit_of_measurement", unit_of_measurement), ("original_name", original_name), ("original_icon", original_icon), ): if value is not UNDEFINED and value != getattr(old, attr_name): changes[attr_name] = value if new_entity_id is not UNDEFINED and new_entity_id != old.entity_id: if self.async_is_registered(new_entity_id): raise ValueError("Entity is already registered") if not valid_entity_id(new_entity_id): raise ValueError("Invalid entity ID") if split_entity_id(new_entity_id)[0] != split_entity_id( entity_id)[0]: raise ValueError("New entity ID should be same domain") self.entities.pop(entity_id) entity_id = changes["entity_id"] = new_entity_id if new_unique_id is not UNDEFINED: conflict_entity_id = self.async_get_entity_id( old.domain, old.platform, new_unique_id) if conflict_entity_id: raise ValueError( f"Unique id '{new_unique_id}' is already in use by " f"'{conflict_entity_id}'") changes["unique_id"] = new_unique_id if not changes: return old self._remove_index(old) new = attr.evolve(old, **changes) self._register_entry(new) self.async_schedule_save() data = { "action": "update", "entity_id": entity_id, "changes": list(changes) } if old.entity_id != entity_id: data["old_entity_id"] = old.entity_id self.hass.bus.async_fire(EVENT_ENTITY_REGISTRY_UPDATED, data) return new
def rm_secret(self, name): return attr.evolve(self, secrets=_deleted(self._secrets, name))
def dummy_config(): return attr.evolve(sac_dummy_config(), framework=FrameworkType.PYTORCH)
def main( output_handler: OutputHandler, target: List[str], pattern: str, lang: str, configs: List[str], no_rewrite_rule_ids: bool = False, jobs: int = 1, include: Optional[List[str]] = None, exclude: Optional[List[str]] = None, strict: bool = False, autofix: bool = False, dryrun: bool = False, disable_nosem: bool = False, dangerously_allow_arbitrary_code_execution_from_rules: bool = False, no_git_ignore: bool = False, timeout: int = DEFAULT_TIMEOUT, max_memory: int = 0, timeout_threshold: int = 0, skip_unknown_extensions: bool = False, severity: Optional[List[str]] = None, ) -> None: if include is None: include = [] if exclude is None: exclude = [] configs_obj, errors = get_config(pattern, lang, configs) all_rules = configs_obj.get_rules(no_rewrite_rule_ids) if severity is None or severity == []: filtered_rules = all_rules else: filtered_rules = [ rule for rule in all_rules if rule.severity in severity ] output_handler.handle_semgrep_errors(errors) if errors and strict: raise SemgrepError( f"run with --strict and there were {len(errors)} errors loading configs", code=MISSING_CONFIG_EXIT_CODE, ) if not pattern: plural = "s" if len(configs_obj.valid) > 1 else "" config_id_if_single = (list(configs_obj.valid.keys())[0] if len(configs_obj.valid) == 1 else "") invalid_msg = (f"({len(errors)} config files were invalid)" if len(errors) else "") logger.debug( f"running {len(filtered_rules)} rules from {len(configs_obj.valid)} config{plural} {config_id_if_single} {invalid_msg}" ) if len(configs_obj.valid) == 0: raise SemgrepError( f"no valid configuration file found ({len(errors)} configs were invalid)", code=MISSING_CONFIG_EXIT_CODE, ) notify_user_of_work(filtered_rules, include, exclude) respect_git_ignore = not no_git_ignore target_manager = TargetManager( includes=include, excludes=exclude, targets=target, respect_git_ignore=respect_git_ignore, output_handler=output_handler, skip_unknown_extensions=skip_unknown_extensions, ) # actually invoke semgrep ( rule_matches_by_rule, debug_steps_by_rule, semgrep_errors, all_targets, profiler, ) = CoreRunner( allow_exec=dangerously_allow_arbitrary_code_execution_from_rules, jobs=jobs, timeout=timeout, max_memory=max_memory, timeout_threshold=timeout_threshold, ).invoke_semgrep(target_manager, filtered_rules) output_handler.handle_semgrep_errors(semgrep_errors) rule_matches_by_rule = { rule: [ attr.evolve(rule_match, is_ignored=rule_match_nosem(rule_match, strict)) for rule_match in rule_matches ] for rule, rule_matches in rule_matches_by_rule.items() } if not disable_nosem: rule_matches_by_rule = { rule: [ rule_match for rule_match in rule_matches if not rule_match._is_ignored ] for rule, rule_matches in rule_matches_by_rule.items() } num_findings = sum(len(v) for v in rule_matches_by_rule.values()) stats_line = f"ran {len(filtered_rules)} rules on {len(all_targets)} files: {num_findings} findings" output_handler.handle_semgrep_core_output(rule_matches_by_rule, debug_steps_by_rule, stats_line, all_targets, profiler) if autofix: apply_fixes(rule_matches_by_rule, dryrun)
def test_semantic_reparse_simple() -> None: TEST_ACT = Act( identifier="2050. évi XD. törvény", publication_date=Date(2050, 3, 4), subject="A nyelvtani tesztelésről", preamble='', children=( Article( identifier="1", children=(Paragraph( text= "Fontos lesz később a tesztelés X tulajdonságiról szóló 2040. évi DX. törvény (a továbbiakban Xtv.) rövidítésének feloldása.", ), )), Article( identifier="2", children=( Paragraph( identifier="1", text= "Bekeverünk a tesztelés Y tulajdonságiról szóló 2041. évi X. törvény dolgaival.", ), Paragraph( identifier="2", text= "Itt megemlítendő a 1. § és a tesztelés Z tulajdonságiról szóló 2041. évi XXX. törvény (a továbbiakban Ztv.) 1. §-a közötti különbség", ), Paragraph( identifier="3", intro="Az Xtv.", wrap_up="szöveg lép.", children=( AlphabeticPoint( identifier="a", text= "12. § (7) bekezdésében a „fontatlan” szövegrész helyébe a „nem fontos”,", ), AlphabeticPoint( identifier="b", text= "11. §-ben a „nemigazán” szövegrész helyébe a „nem”", ), ), ), ), ), Article( identifier="3", children=(Paragraph( text= "Ez a törvény a kihirdetését követő napon lép hatályba."), )), Article( identifier="4", children=(Paragraph( intro= "A Ztv. 12. § (8) bekezdése helyébe a következő rendelkezés lép:", children=(BlockAmendmentContainer(children=(Paragraph( identifier='8', text="Beillesztett referencia: 11. §, vajon lesz baj?" ), ), ), ), ), ), ), ), ) with_semantics_1 = ActSemanticsParser.add_semantics_to_act(TEST_ACT) assert with_semantics_1.is_semantic_parsed assert with_semantics_1.article('1').paragraph().act_id_abbreviations == ( ActIdAbbreviation('Xtv.', '2040. évi DX. törvény'), ) assert with_semantics_1.article('2').paragraph( '2').act_id_abbreviations == (ActIdAbbreviation( 'Ztv.', '2041. évi XXX. törvény'), ) assert with_semantics_1.article('1').paragraph().outgoing_references == ( OutgoingReference(start_pos=55, end_pos=76, reference=Reference(act='2040. évi DX. törvény')), ) assert with_semantics_1.article('2').paragraph( '1').outgoing_references == (OutgoingReference( start_pos=47, end_pos=67, reference=Reference(act='2041. évi X. törvény')), ) assert with_semantics_1.article('2').paragraph('3').point( 'a').semantic_data == (TextAmendment(position=Reference( act='2040. évi DX. törvény', article='12', paragraph='7'), original_text='fontatlan', replacement_text='nem fontos'), ) assert with_semantics_1.article('3').paragraph().semantic_data == ( EnforcementDate(position=None, date=DaysAfterPublication(days=1)), ) assert with_semantics_1.article('4').paragraph().semantic_data == ( BlockAmendment(position=Reference(act='2041. évi XXX. törvény', article='12', paragraph='8'), ), ) a4_children = with_semantics_1.article('4').paragraph().children assert a4_children is not None the_block_amendment = a4_children[0] assert isinstance(the_block_amendment, BlockAmendmentContainer) assert the_block_amendment.semantic_data is None assert the_block_amendment.outgoing_references is None assert the_block_amendment.act_id_abbreviations is None with_semantics_2 = ActSemanticsParser.add_semantics_to_act( with_semantics_1) assert with_semantics_2 is with_semantics_1 modified_paragraph = attr.evolve( with_semantics_1.article("2").paragraph("1"), text="Az 1. § és 3. § egészen fontos.", semantic_data=None, outgoing_references=None, act_id_abbreviations=None, ) modified_article = attr.evolve( with_semantics_1.article("2"), children=(modified_paragraph, ) + with_semantics_1.article("2").children[1:], ) modified_act = attr.evolve( with_semantics_1, children=(with_semantics_1.children[0], modified_article, with_semantics_1.children[2], with_semantics_1.children[3]), ) assert modified_act.article('1').is_semantic_parsed assert not modified_act.article('2').is_semantic_parsed assert modified_act.article('3').is_semantic_parsed assert modified_act.article('4').is_semantic_parsed assert not modified_act.is_semantic_parsed modified_with_semantics = ActSemanticsParser.add_semantics_to_act( modified_act) assert modified_with_semantics.is_semantic_parsed assert modified_with_semantics.article('2').paragraph( '1').outgoing_references == ( OutgoingReference(start_pos=3, end_pos=7, reference=Reference(act=None, article='1')), OutgoingReference(start_pos=11, end_pos=15, reference=Reference(act=None, article='3')), ) # Check if nothing else was touched but the modified part. assert with_semantics_1.article('1') is modified_with_semantics.article( '1') assert with_semantics_1.article('2').paragraph( '2') is modified_with_semantics.article('2').paragraph('2') assert with_semantics_1.article('2').paragraph( '3') is modified_with_semantics.article('2').paragraph('3') assert with_semantics_1.article('3') is modified_with_semantics.article( '3') assert with_semantics_1.article('4') is modified_with_semantics.article( '4')
def filter(self, filter): filters = self.filters.copy() filters.update(filter) return attr.evolve(self, filters=filters)
def _map_panels(self, f): return attr.evolve(self, rows=[r._map_panels(f) for r in self.rows])
def _async_update_device( self, device_id, *, add_config_entry_id=_UNDEF, remove_config_entry_id=_UNDEF, merge_connections=_UNDEF, merge_identifiers=_UNDEF, new_identifiers=_UNDEF, manufacturer=_UNDEF, model=_UNDEF, name=_UNDEF, sw_version=_UNDEF, entry_type=_UNDEF, via_device_id=_UNDEF, area_id=_UNDEF, name_by_user=_UNDEF, ): """Update device attributes.""" old = self.devices[device_id] changes = {} config_entries = old.config_entries if ( add_config_entry_id is not _UNDEF and add_config_entry_id not in old.config_entries ): config_entries = old.config_entries | {add_config_entry_id} if ( remove_config_entry_id is not _UNDEF and remove_config_entry_id in config_entries ): if config_entries == {remove_config_entry_id}: self.async_remove_device(device_id) return config_entries = config_entries - {remove_config_entry_id} if config_entries != old.config_entries: changes["config_entries"] = config_entries for attr_name, value in ( ("connections", merge_connections), ("identifiers", merge_identifiers), ): old_value = getattr(old, attr_name) # If not undefined, check if `value` contains new items. if value is not _UNDEF and not value.issubset(old_value): changes[attr_name] = old_value | value if new_identifiers is not _UNDEF: changes["identifiers"] = new_identifiers for attr_name, value in ( ("manufacturer", manufacturer), ("model", model), ("name", name), ("sw_version", sw_version), ("entry_type", entry_type), ("via_device_id", via_device_id), ): if value is not _UNDEF and value != getattr(old, attr_name): changes[attr_name] = value if area_id is not _UNDEF and area_id != old.area_id: changes["area_id"] = area_id if name_by_user is not _UNDEF and name_by_user != old.name_by_user: changes["name_by_user"] = name_by_user if old.is_new: changes["is_new"] = False if not changes: return old new = attr.evolve(old, **changes) self._update_device(old, new) self.async_schedule_save() self.hass.bus.async_fire( EVENT_DEVICE_REGISTRY_UPDATED, { "action": "create" if "is_new" in changes else "update", "device_id": new.id, }, ) return new
def _map_panels(self, f): return attr.evolve(self, panels=list(map(f, self.panels)))
def test_simple_sac(use_discrete): env = SimpleEnvironment([BRAIN_NAME], use_discrete=use_discrete) config = attr.evolve(SAC_CONFIG) _check_environment_trains(env, {BRAIN_NAME: config})
def full_export( project, paths, target_directory, first_time=False, skip_sunspec=False, include_uuid_in_item=False, ): epcpm.cantosym.export( path=paths.can, can_model=project.models.can, parameters_model=project.models.parameters, ) epcpm.parameterstohierarchy.export( path=paths.hierarchy, can_model=project.models.can, parameters_model=project.models.parameters, ) epcpm.parameterstointerface.export( c_path=paths.interface_c, h_path=paths.interface_c.with_suffix(".h"), can_model=project.models.can, sunspec_model=project.models.sunspec, parameters_model=project.models.parameters, skip_sunspec=skip_sunspec, include_uuid_in_item=include_uuid_in_item, ) epcpm.sunspectoxlsx.export( path=paths.spreadsheet, sunspec_model=project.models.sunspec, parameters_model=project.models.parameters, skip_sunspec=skip_sunspec, ) epcpm.sunspectoxlsx.export( path=paths.spreadsheet_user, sunspec_model=project.models.sunspec, parameters_model=project.models.parameters, skip_sunspec=skip_sunspec, column_filter=attr.evolve( epcpm.sunspectoxlsx.attr_fill(epcpm.sunspectoxlsx.Fields, True), get=False, set=False, item=False, ), ) epcpm.sunspectotablesc.export( c_path=paths.sunspec_tables_c, h_path=paths.sunspec_tables_c.with_suffix(".h"), sunspec_model=project.models.sunspec, skip_sunspec=skip_sunspec, ) epcpm.parameterstosil.export( c_path=paths.sil_c, h_path=paths.sil_c.with_suffix(".h"), parameters_model=project.models.parameters, ) epcpm.sunspectobitfieldsc.export( c_path=paths.sunspec_bitfields_c, h_path=paths.sunspec_bitfields_c.with_suffix(".h"), sunspec_model=project.models.sunspec, include_uuid_in_item=include_uuid_in_item, ) if first_time and not skip_sunspec: epcpm.sunspectomanualc.export( path=paths.sunspec_c, sunspec_model=project.models.sunspec, ) epcpm.sunspectomanualh.export( path=paths.sunspec_c, sunspec_model=project.models.sunspec, ) run_generation_scripts(target_directory, skip_sunspec=skip_sunspec)
def async_update_area(self, area_id: str, changes: dict) -> AreaEntry: """Update existing self.""" old = self.areas[area_id] new = self.areas[area_id] = attr.evolve(old, **changes) self.async_schedule_save() return attr.asdict(new)
def install(self, content_meta=None, force_overwrite=False): """extract the archive to the filesystem and write out install metadata. MUST be called after self.fetch().""" log.debug('install: content_meta=%s, force_overwrite=%s', content_meta, force_overwrite) installed = [] archive_parent_dir = None # FIXME: enum/constant/etc demagic # content_archive_type = 'multi' content_meta = content_meta or self.content_meta # FIXME: really need to move the fetch step elsewhere and do it before, # install should get pass a content_archive (or something more abstract) # TODO: some useful exceptions for 'cant find', 'cant read', 'cant write' archive_path = self._fetch_results.get('archive_path', None) if not archive_path: raise exceptions.GalaxyClientError('No valid content data found for %s', self.src) log.debug("installing from %s", archive_path) content_tar_file, archive_meta = content_archive.load_archive(archive_path) # TODO: do we still need to check the fetched version against the spec version? content_data = self._fetch_results.get('content', {}) # If the requested namespace/version is different than the one we got via find()/fetch()... if content_data.get('fetched_version', content_meta.version) != content_meta.version: log.info('Version "%s" for %s was requested but fetch found version "%s"', content_meta.version, '%s.%s' % (content_meta.namespace, content_meta.name), content_data.get('fetched_version', content_meta.version)) content_meta = attr.evolve(content_meta, version=content_data['fetched_version']) if content_data.get('content_namespace', content_meta.namespace) != content_meta.namespace: log.info('Namespace "%s" for %s was requested but fetch found namespace "%s"', content_meta.namespace, '%s.%s' % (content_meta.namespace, content_meta.name), content_data.get('content_namespace', content_meta.namespace)) content_meta = attr.evolve(content_meta, namespace=content_data['content_namespace']) log.debug('archive_meta: %s', archive_meta) # we strip off any higher-level directories for all of the files contained within # the tar file here. The default is 'github_repo-target'. Gerrit instances, on the other # hand, does not have a parent directory at all. if not os.path.isdir(content_meta.path): log.debug('No content path (%s) found so creating it', content_meta.path) os.makedirs(content_meta.path) if archive_meta.archive_type == 'multi-content': self._content_type = 'all' self.display_callback('- extracting all content from "%s" to %s' % (content_meta.name, self.path)) else: self.display_callback("- extracting all content in %s to content directories" % content_meta.name) log.info('Installing content from archive type: %s', archive_meta.archive_type) if archive_meta.archive_type == 'multi-content': log.info('Installing "%s" as a archive_type=%s content_type=%s install_type=%s ', content_meta.name, archive_meta.archive_type, content_meta.content_type, self.content_install_type) log.info('About to extract content_type=%s "%s" version=%s to %s', content_meta.content_type, content_meta.name, content_meta.version, content_meta.path) log.debug('content_meta: %s', content_meta) res = self._install_contents(content_tar_file, archive_parent_dir, archive_meta.archive_type, content_meta, content_sub_name=self.sub_name, force_overwrite=force_overwrite) installed.append((content_meta, res)) elif archive_meta.archive_type == 'role': log.info('Installing "%s" as a role content archive and content_type=%s (role)', content_meta.name, content_meta.content_type) # log.debug('archive_parent_dir: %s', archive_parent_dir) installed_from_role = self._install_role_archive(content_tar_file, archive_meta=archive_meta, content_meta=content_meta, force_overwrite=force_overwrite) installed.extend(installed_from_role) install_datetime = datetime.datetime.utcnow() repo_info_path = os.path.join(content_meta.path, self.content_meta.namespace, self.content_meta.name, '.galaxy_install_info') repo_install_info = InstallInfo.from_version_date(version=content_meta.version, install_datetime=install_datetime) log.debug('repo_info_path: %s', repo_info_path) install_info.save(repo_install_info, repo_info_path) # return the parsed yaml metadata if archive_meta.archive_type == 'multi-content': self.display_callback("- all content was succssfully installed to %s" % self.path) else: self.display_callback("- %s was installed successfully to %s" % (str(self), self.path)) # rm any temp files created when getting the content archive self._fetcher.cleanup() for item in installed: log.info('Installed content: %s', item[0]) # log.debug('Installed files: %s', pprint.pformat(item[1])) return installed
def test_semantic_reparse_abbrevs() -> None: TEST_ACT = Act( identifier="2050. évi XD. törvény", publication_date=Date(2050, 3, 4), subject="A nyelvtani tesztelésről", preamble='', children=( Article( identifier="1", children=(Paragraph( text= "Fontos lesz később a tesztelés X tulajdonságiról szóló 2040. évi DX. törvény (a továbbiakban Xtv.) rövidítésének feloldása.", ), )), Article( identifier="2", children=( Paragraph( identifier="1", text= "Bekeverünk a tesztelés Y tulajdonságiról szóló 2041. évi X. törvény (a továbbiakban Ytv.) dolgaival", ), Paragraph( identifier="2", text= "Itt megemlítendő az Ytv. 10. §-a és a tesztelés Z tulajdonságiról szóló 2041. évi XXX. törvény (a továbbiakban Ztv.) 1. §-a közötti különbség", ), Paragraph( identifier="3", intro="Mert később használatban van", children=( AlphabeticPoint(identifier="a", text="az Xtv. 1. § c) pontja, és"), AlphabeticPoint(identifier="b", text="az Ytv. 2. §-a."), ), ), ), ), Article( identifier="3", children=(Paragraph( text= "Mégegyszer megemlítendő, hogy fontos az Xtv. 1. §-a, Ytv. 1. §-a, és Ztv. 1337. §-a.", ), )), Article( identifier="4", children=(Paragraph( intro= "Az Ytv. 12. § (8) bekezdése helyébe a következő rendelkezés lép:", children=(BlockAmendmentContainer(children=(Paragraph( identifier='8', text="Beillesztett referencia: 12. §, vajon lesz baj?" ), ), ), ), ), ), ), ), ) with_semantics_1 = ActSemanticsParser.add_semantics_to_act(TEST_ACT) assert with_semantics_1.is_semantic_parsed assert with_semantics_1.article('1').paragraph().act_id_abbreviations == ( ActIdAbbreviation('Xtv.', '2040. évi DX. törvény'), ) assert with_semantics_1.article('2').paragraph( '1').act_id_abbreviations == (ActIdAbbreviation( 'Ytv.', '2041. évi X. törvény'), ) assert with_semantics_1.article('2').paragraph( '2').act_id_abbreviations == (ActIdAbbreviation( 'Ztv.', '2041. évi XXX. törvény'), ) assert with_semantics_1.article('3').paragraph().outgoing_references == ( OutgoingReference(start_pos=40, end_pos=44, reference=Reference(act='2040. évi DX. törvény')), OutgoingReference(start_pos=45, end_pos=51, reference=Reference(act='2040. évi DX. törvény', article='1')), OutgoingReference(start_pos=53, end_pos=57, reference=Reference(act='2041. évi X. törvény')), OutgoingReference(start_pos=58, end_pos=64, reference=Reference(act='2041. évi X. törvény', article='1')), OutgoingReference(start_pos=69, end_pos=73, reference=Reference(act='2041. évi XXX. törvény')), OutgoingReference(start_pos=74, end_pos=83, reference=Reference(act='2041. évi XXX. törvény', article='1337')), ) with_semantics_2 = ActSemanticsParser.add_semantics_to_act( with_semantics_1) # TODO: with_semantics_2 is with_semantics_1 assert with_semantics_2 == with_semantics_1 modified_paragraph = attr.evolve( with_semantics_1.article("2").paragraph("1"), text= "Bekeverünk a tesztelés Y új tulajdonságiról szóló 2057. évi X. törvény (a továbbiakban Ytv.) dolgaival", semantic_data=None, outgoing_references=None, act_id_abbreviations=None, ) modified_article = attr.evolve( with_semantics_1.article("2"), children=(modified_paragraph, ) + with_semantics_1.article("2").children[1:], ) modified_act = attr.evolve( with_semantics_1, children=(with_semantics_1.children[0], modified_article, with_semantics_1.children[2], with_semantics_1.children[3]), ) assert not modified_act.is_semantic_parsed modified_with_semantics = ActSemanticsParser.add_semantics_to_act( modified_act) assert modified_with_semantics.article('2').paragraph( '1').act_id_abbreviations == (ActIdAbbreviation( 'Ytv.', '2057. évi X. törvény'), ) assert modified_with_semantics.article('3').paragraph( ).outgoing_references == ( OutgoingReference(start_pos=40, end_pos=44, reference=Reference(act='2040. évi DX. törvény')), OutgoingReference(start_pos=45, end_pos=51, reference=Reference(act='2040. évi DX. törvény', article='1')), OutgoingReference(start_pos=53, end_pos=57, reference=Reference(act='2057. évi X. törvény')), OutgoingReference(start_pos=58, end_pos=64, reference=Reference(act='2057. évi X. törvény', article='1')), OutgoingReference(start_pos=69, end_pos=73, reference=Reference(act='2041. évi XXX. törvény')), OutgoingReference(start_pos=74, end_pos=83, reference=Reference(act='2041. évi XXX. törvény', article='1337')), ) assert modified_with_semantics.article('4').paragraph().semantic_data == ( BlockAmendment(position=Reference(act='2057. évi X. törvény', article='12', paragraph='8'), ), ) assert with_semantics_1.article('1') is modified_with_semantics.article( '1') # Note that because of the abbreviation change, everything else may be reparsed, # so no asserts for e.g. article('3') # No need to reparse BlockAmendments though a4_children = with_semantics_1.article('4').paragraph().children modified_a4_children = modified_with_semantics.article( '4').paragraph().children assert a4_children is not None assert modified_a4_children is not None assert a4_children[0] is modified_a4_children[0]
def _derelativize(self, metadata_url): return attr.evolve( self, artifact_url=derelativize_url(self.artifact_url, metadata_url), )
def server_computation( # Tensor/Dataset arguments that will be supplied by TFF: server_state: ServerState, gen_delta: tf.keras.Model.weights, disc_delta: tf.keras.Model.weights, generator: tf.keras.Model, discriminator: tf.keras.Model, gen_optimizer: tf.keras.optimizers.Optimizer, disc_optimizer: tf.keras.optimizers.Optimizer) -> ServerState: """The computation to run on the server, training the generator. Args: server_state: The initial `ServerState` for the round. gen_inputs_ds: An infinite `tf.data.Dataset` of inputs to the `generator`. client_output: The (possibly aggregated) `ClientOutput`. generator: The generator. discriminator: The discriminator. server_disc_update_optimizer: Optimizer used to `apply_gradients` based on the client_output delta. train_generator_fn: A function which takes the two networks and generator input and trains the generator. new_aggregation_state: The updated state of the (possibly DP) averaging aggregator. Returns: An updated `ServerState` object. """ # A tf.function can't modify the structure of its input arguments, # so we make a semi-shallow copy: server_state = attr.evolve(server_state, counters=dict(server_state.counters)) tf.nest.map_structure(lambda a, b: a.assign(b), generator.weights, server_state.generator_weights) tf.nest.map_structure(lambda a, b: a.assign(b), discriminator.weights, server_state.discriminator_weights) tf.nest.assert_same_structure(disc_delta, discriminator.weights) grads_and_vars_disc = tf.nest.map_structure(lambda x, v: (-1.0 * x, v), disc_delta, discriminator.weights) grads_and_vars_gen = tf.nest.map_structure(lambda x, v: (-1.0 * x, v), gen_delta, generator.weights) disc_optimizer.apply_gradients(grads_and_vars_disc, name='server_update_disc') gen_optimizer.apply_gradients(grads_and_vars_gen, name='server_update_gen') gen_examples_this_round = tf.constant(0) numrounds = server_state.counters['num_rounds'] round_mod = tf.math.floormod(numrounds, 2, name=None) server_state.meta_gen = tf.cond(tf.math.equal(round_mod, 0), lambda: generator.weights, lambda: server_state.generator_weights) server_state.meta_disc = tf.cond( tf.math.equal(round_mod, 0), lambda: discriminator.weights, lambda: server_state.discriminator_weights) server_state.counters[ 'num_generator_train_examples'] += gen_examples_this_round server_state.generator_weights = _weights(generator) server_state.discriminator_weights = _weights(discriminator) server_state.counters['num_rounds'] += 1 return server_state
def __init__(self, *, connector=None, loop=None, cookies=None, headers=None, skip_auto_headers=None, auth=None, json_serialize=json.dumps, request_class=ClientRequest, response_class=ClientResponse, ws_response_class=ClientWebSocketResponse, version=http.HttpVersion11, cookie_jar=None, connector_owner=True, raise_for_status=False, read_timeout=sentinel, conn_timeout=None, timeout=sentinel, auto_decompress=True, trust_env=False, trace_configs=None): implicit_loop = False if loop is None: if connector is not None: loop = connector._loop else: implicit_loop = True loop = asyncio.get_event_loop() if connector is None: connector = TCPConnector(loop=loop) if connector._loop is not loop: raise RuntimeError( "Session and connector has to use same event loop") self._loop = loop if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) if implicit_loop and not loop.is_running(): warnings.warn( "Creating a client session outside of coroutine is " "a very dangerous idea", stacklevel=2) context = { 'client_session': self, 'message': 'Creating a client session outside ' 'of coroutine' } if self._source_traceback is not None: context['source_traceback'] = self._source_traceback loop.call_exception_handler(context) if cookie_jar is None: cookie_jar = CookieJar(loop=loop) self._cookie_jar = cookie_jar if cookies is not None: self._cookie_jar.update_cookies(cookies) self._connector = connector self._connector_owner = connector_owner self._default_auth = auth self._version = version self._json_serialize = json_serialize if timeout is not sentinel: self._timeout = timeout else: self._timeout = DEFAULT_TIMEOUT if read_timeout is not sentinel: if timeout is not sentinel: raise ValueError("read_timeout and timeout parameters " "conflict, please setup " "timeout.read") else: self._timeout = attr.evolve(self._timeout, total=read_timeout) if conn_timeout is not None: if timeout is not sentinel: raise ValueError("conn_timeout and timeout parameters " "conflict, please setup " "timeout.connect") else: self._timeout = attr.evolve(self._timeout, connect=conn_timeout) self._raise_for_status = raise_for_status self._auto_decompress = auto_decompress self._trust_env = trust_env # Convert to list of tuples if headers: headers = CIMultiDict(headers) else: headers = CIMultiDict() self._default_headers = headers if skip_auto_headers is not None: self._skip_auto_headers = frozenset( [istr(i) for i in skip_auto_headers]) else: self._skip_auto_headers = frozenset() self._request_class = request_class self._response_class = response_class self._ws_response_class = ws_response_class self._trace_configs = trace_configs or [] for trace_config in self._trace_configs: trace_config.freeze()
attr.set_run_validators(False) yield attr.set_run_validators(True) def popid(d): d.pop("id") return d testdata = [ pytest.param( "content", "content_add", list(TEST_OBJECTS["content"]), attr.evolve(model.Content.from_data(data=b"too big"), length=1000), attr.evolve(model.Content.from_data(data=b"to fail"), length=1000), id="content", ), pytest.param( "content", "content_add_metadata", [attr.evolve(cnt, ctime=now()) for cnt in TEST_OBJECTS["content"]], attr.evolve(model.Content.from_data(data=b"too big"), length=1000, ctime=now()), attr.evolve(model.Content.from_data(data=b"to fail"), length=1000, ctime=now()), id="content_metadata", ), pytest.param( "skipped_content", "skipped_content_add", list(TEST_OBJECTS["skipped_content"]),
def previous_line(self) -> "Position": return attr.evolve(self, line=self.line - 1)
def set_batting_event_probs(self, **batting_event_probs): self.batting_event_probabilities = attr.evolve( self.batting_event_probabilities, **batting_event_probs)
def async_update_user(self, user_id: str, changes: dict) -> UserEntry: """Update existing UserEntry.""" old = self.users[user_id] new = self.users[user_id] = attr.evolve(old, **changes) self.async_schedule_save() return new
def next_line(self) -> "Position": return attr.evolve(self, line=self.line + 1)
async def async_load(self) -> None: """Load the registry of schedule entries.""" data = await self._store.async_load() config: Config = Config() areas: "OrderedDict[str, AreaEntry]" = OrderedDict() sensors: "OrderedDict[str, SensorEntry]" = OrderedDict() users: "OrderedDict[str, UserEntry]" = OrderedDict() automations: "OrderedDict[str, AutomationEntry]" = OrderedDict() if data is not None: config = Config( code_arm_required=data["config"]["code_arm_required"], code_disarm_required=data["config"]["code_disarm_required"], code_format=data["config"]["code_format"], disarm_after_trigger=data["config"]["disarm_after_trigger"]) if "mqtt" in data["config"]: config = attr.evolve( config, **{ "mqtt": MqttConfig(**data["config"]["mqtt"]), }) if "master" in data["config"]: config = attr.evolve( config, **{ "master": MasterConfig(**data["config"]["master"]), }) if "areas" in data: for area in data["areas"]: modes = { mode: ModeEntry(enabled=config["enabled"], exit_time=config["exit_time"], entry_time=config["entry_time"], trigger_time=config["trigger_time"]) for (mode, config) in area["modes"].items() } areas[area["area_id"]] = AreaEntry(area_id=area["area_id"], name=area["name"], modes=modes) if "sensors" in data: for sensor in data["sensors"]: sensors[sensor["entity_id"]] = SensorEntry(**sensor) if "users" in data: for user in data["users"]: users[user["user_id"]] = UserEntry(**user) if "automations" in data: for automation in data["automations"]: automations[automation["automation_id"]] = AutomationEntry( **automation) self.config = config self.areas = areas self.sensors = sensors self.automations = automations self.users = users if not areas: self.async_create_area({ "name": "Alarmo", "modes": { STATE_ALARM_ARMED_AWAY: attr.asdict( ModeEntry(enabled=True, exit_time=60, entry_time=60, trigger_time=1800)), STATE_ALARM_ARMED_HOME: attr.asdict(ModeEntry(enabled=True, trigger_time=1800)), STATE_ALARM_ARMED_NIGHT: attr.asdict(ModeEntry()), STATE_ALARM_ARMED_CUSTOM_BYPASS: attr.asdict(ModeEntry()) } })
def copy_and_replace(self, key, new_value) -> "StreamToken": return attr.evolve(self, **{key: new_value})
def _async_update_device( self, device_id: str, *, add_config_entry_id: str | UndefinedType = UNDEFINED, remove_config_entry_id: str | UndefinedType = UNDEFINED, merge_connections: set[tuple[str, str]] | UndefinedType = UNDEFINED, merge_identifiers: set[tuple[str, str]] | UndefinedType = UNDEFINED, new_identifiers: set[tuple[str, str]] | UndefinedType = UNDEFINED, manufacturer: str | None | UndefinedType = UNDEFINED, model: str | None | UndefinedType = UNDEFINED, name: str | None | UndefinedType = UNDEFINED, sw_version: str | None | UndefinedType = UNDEFINED, entry_type: str | None | UndefinedType = UNDEFINED, via_device_id: str | None | UndefinedType = UNDEFINED, area_id: str | None | UndefinedType = UNDEFINED, name_by_user: str | None | UndefinedType = UNDEFINED, disabled_by: str | None | UndefinedType = UNDEFINED, suggested_area: str | None | UndefinedType = UNDEFINED, ) -> DeviceEntry | None: """Update device attributes.""" old = self.devices[device_id] changes: dict[str, Any] = {} config_entries = old.config_entries if (suggested_area not in (UNDEFINED, None, "") and area_id is UNDEFINED and old.area_id is None): area = self.hass.helpers.area_registry.async_get( self.hass).async_get_or_create(suggested_area) area_id = area.id if (add_config_entry_id is not UNDEFINED and add_config_entry_id not in old.config_entries): config_entries = old.config_entries | {add_config_entry_id} if (remove_config_entry_id is not UNDEFINED and remove_config_entry_id in config_entries): if config_entries == {remove_config_entry_id}: self.async_remove_device(device_id) return None config_entries = config_entries - {remove_config_entry_id} if config_entries != old.config_entries: changes["config_entries"] = config_entries for attr_name, setvalue in ( ("connections", merge_connections), ("identifiers", merge_identifiers), ): old_value = getattr(old, attr_name) # If not undefined, check if `value` contains new items. if setvalue is not UNDEFINED and not setvalue.issubset(old_value): changes[attr_name] = old_value | setvalue if new_identifiers is not UNDEFINED: changes["identifiers"] = new_identifiers for attr_name, value in ( ("manufacturer", manufacturer), ("model", model), ("name", name), ("sw_version", sw_version), ("entry_type", entry_type), ("via_device_id", via_device_id), ("disabled_by", disabled_by), ("suggested_area", suggested_area), ): if value is not UNDEFINED and value != getattr(old, attr_name): changes[attr_name] = value if area_id is not UNDEFINED and area_id != old.area_id: changes["area_id"] = area_id if name_by_user is not UNDEFINED and name_by_user != old.name_by_user: changes["name_by_user"] = name_by_user if old.is_new: changes["is_new"] = False if not changes: return old new = attr.evolve(old, **changes) self._update_device(old, new) self.async_schedule_save() self.hass.bus.async_fire( EVENT_DEVICE_REGISTRY_UPDATED, { "action": "create" if "is_new" in changes else "update", "device_id": new.id, }, ) return new
def evolve(self, **kwargs): return attr.evolve(self, **kwargs)