async def cancel(session: CommandSession): global l if int(session.ctx['user_id']) in blacklist: return l2 = more_itertools.only( [x for x in enumerate(l) if x[1].name == session.current_arg_text]) if l2 is None: l2 = more_itertools.only([ x for x in enumerate(l) if str(x[1].id) == session.current_arg_text.strip() ]) if l2 is None: await session.send('未找到') return i = l2[0] if int(session.ctx['user_id']) == l[i].qq or \ await permission.check_permission(get_bot(), session.ctx, permission.GROUP_ADMIN): now = datetime.now() e = l.pop(i) await _save(l) if e.supervise != 0 and ( not e.isFloat and e.begin < now < e.end or e.isFloat and (i == len(l) - 1 or e.begin < now < l[i + 1].begin)): d = ((now - e.begin).total_seconds() - 1) // 60 + 1 if add_time(e.qq, d): await session.send('您已成功通过试用期转正!') await _save(l) await session.send('成功删除') ret = await change_des_to_list() if json.loads(ret)['code'] != 0: await session.send('更新到直播间失败') else: await session.send('非管理员不可删除别人的')
def visitBoot_stanza( self, ctx: RefindConfigParser.Boot_stanzaContext) -> BootStanza: menu_entry_context = ctx.menu_entry() menu_entry = menu_entry_context.accept(MenuEntryVisitor()) main_options = OptionVisitor.map_to_options_dict( checked_cast(list[ParserRuleContext], ctx.main_option())) volume = only(always_iterable(main_options.get(RefindOption.VOLUME))) loader = only(always_iterable(main_options.get(RefindOption.LOADER))) initrd = only(always_iterable(main_options.get(RefindOption.INITRD))) icon = only(always_iterable(main_options.get(RefindOption.ICON))) os_type = only(always_iterable(main_options.get(RefindOption.OS_TYPE))) graphics = only( always_iterable(main_options.get(RefindOption.GRAPHICS))) boot_options = only( always_iterable(main_options.get(RefindOption.BOOT_OPTIONS))) firmware_bootnum = only( always_iterable(main_options.get(RefindOption.FIRMWARE_BOOTNUM))) disabled = only(always_iterable(main_options.get( RefindOption.DISABLED)), default=False) sub_menus = always_iterable( main_options.get(RefindOption.SUB_MENU_ENTRY)) return BootStanza( menu_entry, volume, loader, initrd, icon, os_type, graphics, BootOptions(boot_options), firmware_bootnum, disabled, ).with_sub_menus(sub_menus)
def get_seq(self): # Explicitly cache this property, rather than relying on the caching # provided by autoprop. We go out of our way to do this because (i) # the sequence is especially expensive to look up and (ii) we know that # it won't be affected by the cleanup steps. if self._seq: return self._seq seq = self._attrs.get('seq') # Allow the retrieval of the sequence to be deferred, e.g. so unused # sequences never have to be read from disc. if callable(seq): seq = seq() # If we have instructions for how to make this molecule, try getting # the sequence from that. if not seq: seq = only( self.get_synthesis_attr('product_seqs', []), too_long=QueryError("protocol has multiple sequences", culprit=self), ) if not seq: raise QueryError("no sequence specified", culprit=self) self._seq = seq return seq
def _is_snapshot_deleted(self, deleted_directory: Path) -> bool: persistence_provider = self._persistence_provider previous_run_result = persistence_provider.get_previous_run_result() bootable_snapshots = previous_run_result.bootable_snapshots if has_items(bootable_snapshots): deleted_snapshot = only( snapshot for snapshot in bootable_snapshots if snapshot.is_located_in(deleted_directory)) if deleted_snapshot is not None: deleted_snapshots = self._deleted_snapshots deletion_lock = self._deletion_lock with deletion_lock: if deleted_snapshot not in deleted_snapshots: snapshot_manipulation = ( self.package_config.snapshot_manipulation) cleanup_exclusion = snapshot_manipulation.cleanup_exclusion deleted_snapshots.add(deleted_snapshot) if deleted_snapshot in cleanup_exclusion: raise SnapshotExcludedFromDeletionError( f"The deleted snapshot ('{deleted_directory}') " "is explicitly excluded from cleanup!") return True return False
def iter_values(self, key, log): layer_1 = appcli.DictLayer(self.presets_getter()) preset = only(layer_1.iter_values(self.key_getter(), log)) if preset is not None: layer_2 = appcli.DictLayer(preset, schema=self.schema) yield from layer_2.iter_values(key, log)
def test_matching_static_vs_dynamic_graphs(): target_object = BOX train_obj_object = object_variable("obj-with-color", target_object) obj_template = Phase1SituationTemplate( "colored-obj-object", salient_object_variables=[train_obj_object]) template = all_possible(obj_template, chooser=PHASE1_CHOOSER_FACTORY(), ontology=GAILA_PHASE_1_ONTOLOGY) train_curriculum = phase1_instances("all obj situations", situations=template) perceptual_representation = only(train_curriculum.instances())[2] perception_graph = graph_without_learner( PerceptionGraph.from_frame(perceptual_representation.frames[0])) temporal_perception_graph = perception_graph.copy_with_temporal_scopes( temporal_scopes=[TemporalScope.AFTER]) perception_pattern = PerceptionGraphPattern.from_graph( perception_graph).perception_graph_pattern temporal_perception_pattern = perception_pattern.copy_with_temporal_scopes( required_temporal_scopes=[TemporalScope.AFTER]) # Test runtime error for matching static pattern against dynamic graph and vice versa with pytest.raises(RuntimeError): perception_pattern.matcher(temporal_perception_graph, match_mode=MatchMode.NON_OBJECT) with pytest.raises(RuntimeError): temporal_perception_pattern.matcher(perception_graph, match_mode=MatchMode.NON_OBJECT)
def get_sd_person_changed( identifier_type: IdType, identifier: str, xml_root: _Element ) -> SdPersonChange: # Get the request date timestamps request_structure = xml_root.find("RequestStructure") activation_date = request_structure.find("ActivationDate").text.strip() deactivation_date = request_structure.find("DeactivationDate").text.strip() def id_match(id_type: IdType, id_: str, person: _Element) -> bool: if id_type == IdType.CPR: id_element = person.find(id_type.value) else: employment_element = person.find("Employment") id_element = employment_element.find(id_type.value) if id_ == id_element.text.strip(): return True return False person_elements = xml_root.findall("Person") persons = filter(partial(id_match, identifier_type, identifier), person_elements) sd_person_changed = SdPersonChange( start_date=activation_date, end_date=deactivation_date, change=only(persons) ) return sd_person_changed
def _compute_axis_info( self, object_var_to_instantiations: Mapping[TemplateObjectVariable, SituationObject], ) -> AxesInfo[SituationObject]: # if there is an addressee, then we determine which axis # of each object faces the addressee addressees = immutableset( obj for obj in object_var_to_instantiations.values() if IS_ADDRESSEE in obj.properties) if addressees: if len(addressees) > 1: raise RuntimeError("Multiple addressees not supported") else: addressee: SituationObject = only(addressees) return AxesInfo( addressee=addressee, axes_facing=[ ( addressee, # TODO: fix this hack HorizontalAxisOfObject( # type: ignore obj, index=1).to_concrete_axis(None), ) for obj in object_var_to_instantiations.values() if obj.axes ], ) else: return AxesInfo()
def required_action_description( self, action_type: OntologyNode, semantic_roles: Iterable[OntologyNode]) -> ActionDescription: semantic_roles_set = immutableset(semantic_roles) descriptions_for_action_type = self.action_to_description[action_type] matching_descriptions = immutableset( description for description in descriptions_for_action_type if description.frame.semantic_roles == semantic_roles_set) if matching_descriptions: if len(matching_descriptions) == 1: return only(matching_descriptions) else: raise RuntimeError( f"Multiple action descriptions match action type " f"{action_type} and roles {semantic_roles_set}") else: available_frames: Any = [ immutableset(description.frame.roles_to_variables.keys()) for description in descriptions_for_action_type ] raise RuntimeError( f"No action descriptions match action type " f"{action_type} and roles {semantic_roles_set}. " f"Known frames for {action_type} are " f"{available_frames}")
def has_it_system(uuid, ad_object): mo_itsystem_uuid = self.mapping["it_systems"][ "samAccountName"] itconnections = self._read_itconnections( uuid, mo_itsystem_uuid) mo_username, _ = only(itconnections, ("", "")) return mo_username != ""
def to_concrete_axis( self, axes_info: Optional[AxesInfo[_ObjectT]] # pylint:disable=unused-argument ) -> GeonAxis: if not axes_info: raise RuntimeError( "FacingAddresseeAxis cannot be applied if axis info not available" ) if not isinstance(self._object, HasAxes): raise RuntimeError( "Can only instantiate an axis function if the object is of a " "concrete type (e.g. perception or situation object)" ) addressee: Optional[_ObjectT] = axes_info.addressee if not addressee: raise RuntimeError("Addressee must be specified to use FacingAddresseeAxis") object_axes = immutableset(self._object.axes.all_axes) object_axes_facing_addressee = axes_info.axes_facing[addressee].intersection( object_axes ) if object_axes_facing_addressee: if len(object_axes_facing_addressee) == 1: return only(object_axes_facing_addressee) else: raise RuntimeError("Cannot handle multiple axes facing the addressee.") else: raise RuntimeError( f"Could not find axis of {self._object} facing addressee {addressee}. Axis info is " f"{axes_info}. Axes of object is {object_axes}" )
def test_successfully_extending_partial_match(): """ Tests whether we can match a perception pattern against a perception graph when initializing the search from a partial match. """ target_object = BOX # Create train and test templates for the target objects train_obj_object = object_variable("obj-with-color", target_object) obj_template = Phase1SituationTemplate( "colored-obj-object", salient_object_variables=[train_obj_object]) template = all_possible(obj_template, chooser=PHASE1_CHOOSER_FACTORY(), ontology=GAILA_PHASE_1_ONTOLOGY) train_curriculum = phase1_instances("all obj situations", situations=template) perceptual_representation = only(train_curriculum.instances())[2] # Original perception graph perception = PerceptionGraph.from_frame( perceptual_representation.frames[0]) # Create a perception pattern for the whole thing # and also a perception pattern for a subset of the whole pattern whole_perception_pattern = PerceptionGraphPattern.from_graph( perception).perception_graph_pattern partial_digraph = whole_perception_pattern.copy_as_digraph() partial_digraph.remove_nodes_from([ node for node in partial_digraph.nodes if isinstance(node, IsColorNodePredicate) ]) partial_perception_pattern = PerceptionGraphPattern(partial_digraph) # get our initial match by matching the partial pattern matcher = partial_perception_pattern.matcher( perception, match_mode=MatchMode.NON_OBJECT) partial_match: PerceptionGraphPatternMatch = first( matcher.matches(use_lookahead_pruning=True)) partial_mapping = partial_match.pattern_node_to_matched_graph_node # Try to extend the partial mapping, to create a complete mapping matcher_2 = whole_perception_pattern.matcher( perception, match_mode=MatchMode.NON_OBJECT) complete_match: PerceptionGraphPatternMatch = first( matcher_2.matches(initial_partial_match=partial_mapping, use_lookahead_pruning=True), None, ) complete_mapping = complete_match.pattern_node_to_matched_graph_node assert len(complete_mapping) == len(perception.copy_as_digraph().nodes) assert len(complete_mapping) == len( whole_perception_pattern.copy_as_digraph().nodes)
def __init__(self, id): #with open(config.rel(f'games\\snakebird\\{id}.txt')) as f: with open(f'C:\\\coolq_data\\games\\snakebird\\{id}.txt') as f: self.board = [list(line.strip()) for line in f.readlines()] self.border = ((0, len(self.board)), (0, len(self.board[0]))) # 0: blank 1: wall 2: food 3: spike 8: portal 9: end Aaa: snake IIIJJ: block Z: void T: tail _head = dict([(c, more_itertools.only([ (i, line.index(c)) for i, line in enumerate(self.board) if c in line ])) for c in 'ABC']) self.snake = {} # 蛇头在list尾部 for c, head in _head.items(): if head is None: continue self.snake[c] = [head] t = head while 1: for dir in self.dir: s = add(t, dir) if in_border(s, self.border) and self[s] == c.lower( ) and s not in self.snake[c]: self.snake[c] = [s] + self.snake[c] t = s break else: break self.cal_food() self.win = more_itertools.only([(i, line.index('9')) for i, line in enumerate(self.board) if '9' in line]) self[self.win] = '0' self.portal = functools.reduce( lambda x, y: x + y, [[(i, j) for j in more_itertools.locate(line, lambda x: x == '8')] for i, line in enumerate(self.board)]) assert (len(self.portal) in {0, 2}) if len(self.portal) == 2: self[self.portal[0]] = self[self.portal[1]] = '0' self.block = {} # TODO self.stack = [] self.activate = 'A'
def find_param(obj, name=None): from more_itertools import only class_attrs = obj.__class__.__dict__ if name: return class_attrs[name] else: params = (x for x in class_attrs.values() if isinstance(x, byoc.param)) default = byoc.param() default.__set_name__(obj.__class__, '') return only(params, default)
def visitSub_menu(self, ctx: RefindConfigParser.Sub_menuContext) -> SubMenu: menu_entry_context = ctx.menu_entry() menu_entry = menu_entry_context.accept(MenuEntryVisitor()) sub_options = OptionVisitor.map_to_options_dict( checked_cast(list[ParserRuleContext], ctx.sub_option())) loader = only(always_iterable(sub_options.get(RefindOption.LOADER))) initrd = only(always_iterable(sub_options.get(RefindOption.INITRD))) graphics = only(always_iterable(sub_options.get( RefindOption.GRAPHICS))) boot_options = only( always_iterable(sub_options.get(RefindOption.BOOT_OPTIONS))) add_boot_options = only( always_iterable(sub_options.get(RefindOption.ADD_BOOT_OPTIONS))) disabled = only(always_iterable(sub_options.get( RefindOption.DISABLED)), default=False) return SubMenu( menu_entry, loader, initrd, graphics, BootOptions(boot_options) if boot_options is not None else None, BootOptions(add_boot_options), disabled, )
def test_perceive_explicit_relations(): # we want to test that relations explicitly called out in the situation are perceived. # Such relations fall into three buckets: # those which hold before an action, # those which hold after an action, # and those which hold both before and after an action. # To test all three of these at once, we use a situation where # (a) Mom is putting a ball on a table # (b) before the action the ball is far from a box, # (c) but after the action the ball is near the box, # (d) throughout the action the box is on the table. mom = situation_object(MOM) ball = situation_object(BALL) box = situation_object(BOX) table = situation_object(TABLE) situation = HighLevelSemanticsSituation( ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[mom, box, ball, table], always_relations=[on(ball, table)], before_action_relations=[far(ball, box)], after_action_relations=[near(ball, box)], actions=[ Action( PUT, argument_roles_to_fillers=[ (AGENT, mom), (THEME, ball), ( GOAL, Region( reference_object=table, distance=EXTERIOR_BUT_IN_CONTACT, direction=GRAVITATIONAL_UP, ), ), ], ) ], ) perception = _PERCEPTION_GENERATOR.generate_perception( situation, chooser=RandomChooser.for_seed(0) ) ball_perception = perception_with_handle(perception.frames[0], "**ball_0") box_perception = perception_with_handle(perception.frames[0], "**box_0") table_perception = perception_with_handle(perception.frames[0], "**table_0") assert only(on(ball_perception, table_perception)) in perception.frames[0].relations assert only(on(ball_perception, table_perception)) in perception.frames[0].relations assert only(far(ball_perception, box_perception)) in perception.frames[0].relations assert ( only(far(ball_perception, box_perception)) not in perception.frames[1].relations ) assert ( only(near(ball_perception, box_perception)) not in perception.frames[0].relations ) assert only(near(ball_perception, box_perception)) in perception.frames[1].relations
def __init__(self): self.settings = load_settings() self.root_ou_uuid = self.settings["integrations.ad.import_ou.mo_unit_uuid"] self.helper = MoraHelper(hostname=self.settings["mora.base"], use_cache=False) self.org_uuid = self.helper.read_organisation() self.ad_reader = ADParameterReader() self.ad_reader.cache_all(print_progress=True) its = self.helper.read_it_systems() AD_its = only(filter(lambda x: x["name"] == constants.AD_it_system, its)) self.AD_it_system_uuid = AD_its["uuid"]
def find_type(opus_id, full_history): """Check if the object with the given id is a unit or an employee.""" dumps = get_opus_filereader().list_opus_files() # Search in newest file first opus_files = sorted(dumps, reverse=True) if not full_history: opus_files = [first(opus_files)] for f in opus_files: units, employees = opus_helpers.parser(dumps[f], opus_id=opus_id) employees, terminated_employees = opus_helpers.split_employees_leaves( employees) employees = list(employees) if units: return "organisationenhed", only(units) elif employees: return "bruger", only(employees) terminated_employees = list(terminated_employees) if terminated_employees: msg = "Employee was terminated, try --full-history" else: msg = f"No object with {opus_id=} was found." raise ValueError(msg)
def from_index(self, value: str) -> Optional[JSON]: """ >>> a = ValueAndUnit() >>> a.from_index('20 year') {'value': '20', 'unit': 'year'} >>> a.from_index('20') {'value': '20', 'unit': None} >>> a.from_index('~null') is None True Although 'year' looks like a unit, we intentionally treat it like a value because this class does not enforce any constraints on value or unit other than it not contain spaces. >>> a.from_index('year') {'value': 'year', 'unit': None} >>> a.from_index('20 ') Traceback (most recent call last): ... ValueError: too many items in iterable (expected 1) >>> a.from_index(' year') Traceback (most recent call last): ... AssertionError >>> a.from_index('1 ') Traceback (most recent call last): ... AssertionError >>> a.from_index('') Traceback (most recent call last): ... AssertionError """ if value == NullableString.null_string: return None else: i = iter(value.split(' ')) value = next(i) # only() fails with more than one item left in the iterator unit = only(i) assert value, value assert unit is None or unit, unit return {'value': value, 'unit': unit}
def check_relations( session, base: str, uuid: UUID, relation_type: str = "organisation/organisationfunktion", ) -> List[dict]: """Find all objects related to the class with the given uuid. Returns a list of objects, or an empty list if no objects related to the given uuid are found. """ r = session.get( base + f"/{relation_type}?vilkaarligrel={str(uuid)}&list=true&virkningfra=-infinity" ) r.raise_for_status() res = r.json()["results"] return only(res, default=[])
def _edit_it_system(self, uuid, ad_object): mo_itsystem_uuid = self.mapping["it_systems"]["samAccountName"] itconnections = self._read_itconnections(uuid, mo_itsystem_uuid) # Here it_systems is a 2 tuple (mo_username, binding_uuid) mo_username, binding_uuid = only(itconnections, ("", "")) # Username currently in AD ad_username = ad_object["SamAccountName"] # If mo_username is blank, we found a user who needs a new entry created if mo_username == "": self._create_it_system(uuid, ad_username, mo_itsystem_uuid) self.stats["it_systems"] += 1 self.stats["users"].add(uuid) elif mo_username != ad_username: # We need to update the mo_username self._update_it_system(ad_username, binding_uuid) self.stats["it_systems"] += 1 self.stats["users"].add(uuid)
def test_path_from_action_description(): ball = situation_object(BALL) situation = HighLevelSemanticsSituation( ontology=GAILA_PHASE_1_ONTOLOGY, salient_objects=[ball], actions=[Action(FALL, argument_roles_to_fillers=[(THEME, ball)])], ) perception = _PERCEPTION_GENERATOR.generate_perception( situation, chooser=RandomChooser.for_seed(0) ) ball_perception = perception_with_handle(perception.frames[0], "**ball_0") ground_perception = perception_with_handle(perception.frames[0], "the ground") assert perception.during assert perception.during.objects_to_paths assert len(perception.during.objects_to_paths) == 1 path = only(perception.during.objects_to_paths[ball_perception]) assert path.reference_object == ground_perception assert path.operator == TOWARD
def instantiate_ontology_node( ontology_node: OntologyNode, *, properties: Iterable[OntologyNode] = immutableset(), debug_handle: Optional[str] = None, ontology: Ontology, ) -> "SituationObject": """ Make a `SituationObject` from the object type *ontology_node* with properties *properties*. The *properties* and ontology node must all come from *ontology*. """ schema_axis_to_object_axis: Mapping[GeonAxis, GeonAxis] if ontology.has_property(ontology_node, IS_SUBSTANCE): # it's not clear what the object_concrete_axes should be for substances, # so we just use the world object_concrete_axes for now schema_axis_to_object_axis = immutabledict() object_concrete_axes = WORLD_AXES else: structural_schemata = ontology.structural_schemata(ontology_node) if not structural_schemata: raise RuntimeError( f"No structural schema found for {ontology_node}") if len(structural_schemata) > 1: raise RuntimeError( f"Multiple structural schemata available for {ontology_node}, " f"please construct the SituationObject manually: " f"{structural_schemata}") schema_abstract_axes = only(structural_schemata).axes # The copy is needed or e.g. all tires of a truck # would share the same axis objects. object_concrete_axes = schema_abstract_axes.copy() schema_axis_to_object_axis = immutabledict( zip(schema_abstract_axes.all_axes, object_concrete_axes.all_axes)) return SituationObject( ontology_node=ontology_node, properties=properties, debug_handle=debug_handle if debug_handle else ontology_node.handle, axes=object_concrete_axes, schema_axis_to_object_axis=schema_axis_to_object_axis, )
def test_perception_graph_post_init_edge_cases(): target_object = BOX train_obj_object = object_variable("obj-with-color", target_object) obj_template = Phase1SituationTemplate( "colored-obj-object", salient_object_variables=[train_obj_object]) template = all_possible(obj_template, chooser=PHASE1_CHOOSER_FACTORY(), ontology=GAILA_PHASE_1_ONTOLOGY) train_curriculum = phase1_instances("all obj situations", situations=template) perceptual_representation = only(train_curriculum.instances())[2] perception_graph = graph_without_learner( PerceptionGraph.from_frame(perceptual_representation.frames[0])) temporal_perception_graph = perception_graph.copy_with_temporal_scopes( temporal_scopes=[TemporalScope.AFTER]) temporal_digraph = temporal_perception_graph.copy_as_digraph() # Test valid edge label # The only feasible test seems to be the instation, since creating a corrupt instance throws the same RuntimeError with pytest.raises(RuntimeError): TemporallyScopedEdgeLabel(None) # In a dynamic graph, all edge labels must be wrapped in TemporallyScopedEdgeLabel new_graph = DiGraph() for (source, target) in temporal_digraph.edges(): new_graph.add_edge(source, target) new_graph[source][target]["label"] = None with pytest.raises(RuntimeError): PerceptionGraph(new_graph, dynamic=True) # TemporallyScopedEdgeLabels may not appear in a static graph new_graph = DiGraph() for (source, target) in temporal_digraph.edges(): new_graph.add_edge(source, target) new_graph[source][target]["label"] = TemporallyScopedEdgeLabel( "attribute", [TemporalScope.AFTER]) with pytest.raises(RuntimeError): PerceptionGraph(new_graph) # Every edge in a PerceptionGraph must have a 'label new_graph = DiGraph() for (source, target) in temporal_digraph.edges(): new_graph.add_edge(source, target) with pytest.raises(RuntimeError): PerceptionGraph(new_graph)
async def thwiki_supervise(session: CommandSession): group_id = session.ctx['group_id'] if group_id not in config.group_id_dict['thwiki_supervise']: return qq = session.ctx['user_id'] i = session.current_arg_text.split(' ') if len(i) == 1: id = int(i[0]) t = True elif len(i) == 2: id = int(i[0]) t = not (i[1] == 'false' or i[1] == 'False' or i[1] == 'f' or i[1] == 'F') else: await session.send('使用-thwiki.supervise 直播id [可选:True/False]') return ret = more_itertools.only([x for x in l if x.id == id]) if ret is None: await session.send('未发现此id的直播提交') elif ret.supervise == -1: await session.send('此直播提交者已有权限') elif ret.supervise > 0 and t: await session.send('此直播提交已有监视者') elif ret.supervise != qq and not t: await session.send('删除失败') else: if t: ret.supervise = qq if ret.begin < datetime.now(): ret.begin = datetime.now() await _save(l) await session.send('成功提交监视') for group in config.group_id_dict['thwiki_send']: await get_bot().send_group_msg(group_id=group, message=ret.str_with_at()) else: ret.supervise = 0 await _save(l) await session.send('成功删除监视') for group in config.group_id_dict['thwiki_send']: await get_bot().send_group_msg(group_id=group, message=ret.str_with_at())
def connect_it_system(self, username, it_system, employee, person_uuid): it_system_uuid = self.it_systems[it_system] current = self.helper.get_e_itsystems(person_uuid, it_system_uuid=it_system_uuid) try: current = only(current, default={}) except ValueError: logger.warning( f"Skipped connecting {it_system} IT system . More than one IT system found for {person_uuid=}" ) return if not (username or current): return # New it-system account if not current: payload = payloads.connect_it_system_to_user( username, it_system_uuid, person_uuid, self.xml_date.strftime("%Y-%m-%d"), ) logger.debug(f"{it_system} account payload: {payload}") response = self.helper._mo_post("details/create", payload) assert response.status_code == 201 logger.info(f"Added {it_system} info for {person_uuid}") # Deleted it-system account elif not username: self.terminate_detail(current["uuid"], detail_type="it") logger.info(f"No {it_system} info for {person_uuid} any longer") # Changed account name. Only supports one account pr it-system elif current.get("user_key") != username: payload = payloads.edit_it_system_username( current["uuid"], username, self.xml_date.strftime("%Y-%m-%d"), ) logger.debug(f"{it_system} account payload: {payload}") response = self.helper._mo_post("details/edit", payload) response.raise_for_status() logger.info(f"Changed {it_system} info for {person_uuid}")
def test_copy_with_temporal_scopes_content(): """ Tests whether copy_with_temporal_scopes converts graphs to be dynamic as intended """ # We use a situation to generate the perceptual representation # for a box with color. target_object = BOX train_obj_object = object_variable("obj-with-color", target_object) obj_template = Phase1SituationTemplate( "colored-obj-object", salient_object_variables=[train_obj_object]) template = all_possible(obj_template, chooser=PHASE1_CHOOSER_FACTORY(), ontology=GAILA_PHASE_1_ONTOLOGY) train_curriculum = phase1_instances("all obj situations", situations=template) perceptual_representation = only(train_curriculum.instances())[2] perception_graph = graph_without_learner( PerceptionGraph.from_frame(perceptual_representation.frames[0])) temporal_perception_graph = perception_graph.copy_with_temporal_scopes( temporal_scopes=[TemporalScope.AFTER]) for (source, target) in perception_graph.copy_as_digraph().edges(): assert not isinstance( perception_graph.copy_as_digraph()[source][target]["label"], TemporallyScopedEdgeLabel, ) for (source, target) in temporal_perception_graph.copy_as_digraph().edges(): # Check type, and then the content label = temporal_perception_graph.copy_as_digraph( )[source][target]["label"] assert isinstance(label, TemporallyScopedEdgeLabel) assert (label.attribute == perception_graph.copy_as_digraph()[source] [target]["label"]) assert all(specifier in [TemporalScope.AFTER] for specifier in label.temporal_specifiers)
def pretty_descriptions( descriptions: Mapping[LinguisticDescription, float], num_descriptions: int, *, sort_by_length: bool, ) -> str: if len(descriptions) > 1: top_descriptions = take( num_descriptions, sorted(descriptions.items(), key=_by_length if sort_by_length else _by_score), ) parts = ["<ul>"] parts.extend([ f"<li>{description.as_token_string()} ({score:.2})</li>" for (description, score) in top_descriptions ]) parts.append("</ul>") return "\n".join(parts) elif len(descriptions) == 1: return "".join(only(descriptions).as_token_string()) else: return ""
def _decide_primary(self, mo_engagements): """Decide which of the engagements in mo_engagements is the primary one. Args: mo_engagements: List of engagements Returns: 2-tuple: UUID: The UUID of the primary engagement. primary_type_key: The type of the primary. """ # First we attempt to find a fixed primary engagement. # If multiple are found, we throw an exception, as only one is allowed. # If one is found, it is our primary and we are done. # If none are found, we need to calculate the primary engagement. find_fixed_primary = partial(self._predicate_primary_is, "fixed_primary") # Iterator of UUIDs of engagements with primary = fixed_primary fixed_primary_engagement_uuids = map( itemgetter("uuid"), filter(find_fixed_primary, mo_engagements) ) # UUID of engagement with primary = fixed_primary, exception or None fixed = only( fixed_primary_engagement_uuids, None, too_long=MultipleFixedPrimaries ) if fixed: return fixed, "fixed_primary" # No fixed engagements, thus we must calculate the primary engagement. # # The calulcation of primary engagement depends on the underlying # implementation, thus we simply call self._find_primary here. primary = self._find_primary(mo_engagements) if primary: return primary, "primary" raise NoPrimaryFound()
def split(group): name, classes = group classes = list(classes) no_scope, scope = partition(lambda x: x["name"] != x["user_key"], classes) return only(no_scope), only(scope)