def __init__(self, *, ui=None, controller_depth=0, parent_controller=None, workspace_arguments=None, stopping_condition=None): History.AddArtefact(self, ObjectType.CONTROLLER, "Created controller") #: How deeply in the stack this controller is. The top-level controller has a depth #: of 0, Subspaces it spawns 1, and so forth. self.controller_depth = controller_depth #: If this is a controller of a subspace, this points to parent_controller. self.parent_controller = parent_controller #: The coderack. self.coderack = self.coderack_class() #: The stream. self.stream = self.stream_class(self) if self.workspace_class: if workspace_arguments is None: workspace_arguments = dict() #: Workspace, constructed if workspace_class is defined. The workspace is constructed #: using workspace_arguments. self.workspace = self.workspace_class( **workspace_arguments) # pylint: disable=E1102 if self.ltm_name: #: LTM, if any self.ltm = LTMManager.GetLTM(self.ltm_name) else: self.ltm = None #: Number of steps taken self.steps_taken = 0 #: The UI running this controller. May be a GUI or a Guided UI (which knows how to #: answer questions that'd normally be answered by a user in a GUI). Any subspace #: spawned by this space shall inherit the ui. self.ui = ui #: Stopping condition (for SxS and batch modes). self.stopping_condition = stopping_condition # Add any routine codelets... self._AddRoutineCodelets(force=True)
def __init__(self): #: Variables are a superset of Attributes: they additionally contain internal, attribute-like #: things, that don't need to be made public. There are no constraints on the values for #: non-attribute variables. self._Variables = set() # We will add to these. self._Variables.update(self._Attributes) #: Compiled rules are obtained from the string versions by parsing and seeking out variables. self._CompiledRules = [] for rule in self._Rules: target, rest = rule.split(sep=':', maxsplit=1) rule_obj = Rule(target=target.strip(), expression=rest.lstrip(), ctx=self._Context) self._Variables.add(target.strip()) self._Variables.update(x for x in rule_obj.GetVars()) self._CompiledRules.append(rule_obj) #: Compiled checks. These are expressed as rules, but there is no target. self._CompiledChecks = [] for rule in self._Checks: rule_obj = Rule(target=None, expression=rule.strip(), ctx=self._Context) self._Variables.update(x for x in rule_obj.GetVars()) self._CompiledChecks.append(rule_obj) self.SanityCheck() History.AddArtefact(self, artefact_type=ObjectType.CATEGORY)
def _PlonkIntoPlace(self, group, *, parents=None): """Anchors the group into the workspace. Assumes that conflicts have already been checked for. """ groups_at_this_location = list(self.GetGroupsWithSpan(Exactly(group.start_pos), Exactly(group.end_pos))) if groups_at_this_location: # Merge current group into the group at this location, as it were. This merging only # adds the underlying mapping. However, if we extend groups to make multiple # underlying mappings possible, this needs to be updated too. group_at_this_location = groups_at_this_location[ 0] # There can be only 1 if (group.object.underlying_mapping_set and not group_at_this_location.object.underlying_mapping_set): group_at_this_location.object.underlying_mapping_set = set( group.object.underlying_mapping_set) # We should also merge all pieces of the group into the # corresponding existing pieces. for x in group.items: self._PlonkIntoPlace(x) # Ignore output, we don't need it. group_at_this_location.object.AddCategoriesFrom(group.object) return group_at_this_location # Group does not exist, create one. pieces = [self._PlonkIntoPlace(x) for x in group.items] new_object = SAnchored.Create(pieces, underlying_mapping_set=set( group.object.underlying_mapping_set)) new_object.object.AddCategoriesFrom(group.object) self.groups.add(new_object) History.AddArtefact(new_object, ObjectType.WS_GROUP, "Initial creation: [%d, %d]" % (new_object.start_pos, new_object.end_pos), parents=parents) return new_object
def __init__(self, *, log_msg='', parents=[]): PSFocusable.__init__(self) self.relations = dict() self._span = None History.AddArtefact(item=self, artefact_type=ObjectType.WS_GROUP, log_msg=log_msg, parents=parents)
def __init__(self, *, first, second, parents=[]): self.first = first self.second = second Categorizable.__init__(self) if History._is_history_on: roles = {first._hid: "first end", second._hid: "second end"} History.AddArtefact(self, ObjectType.WS_RELN, "", parents, roles) History.Note("Created relation")
def AddCodelet(self, codelet, *, msg="", parents=[]): """Adds codelet to coderack. Removes some existing codelet if needed.""" kLogger.debug('Codelet added: %s', str(codelet.family)) if self._codelet_count == self._max_capacity: self._ExpungeSomeCodelet() self._codelets.add(codelet) self._codelet_count += 1 self._urgency_sum += codelet.urgency History.AddArtefact(codelet, ObjectType.CODELET, "Codelet %s %s" % (codelet.family.__name__, msg), parents)
def __init__(self, first, second, *, mapping_set): #: Typically, the object on the left. self.first = first #: Typically, the object on the right. self.second = second #: The set of mappings any of which transform the left object to the right object. self.mapping_set = mapping_set History.AddArtefact(self, ObjectType.WS_RELN, "", parents=(self.first, self.second))
def InsertElement(self, element): """Insert an element beyond the last element.""" assert isinstance(element, SElement) anchored = SAnchored(sobj=element, items=[], start_pos=self.num_elements, end_pos=self.num_elements, is_sequence_element=True) self.num_elements += 1 History.AddArtefact(anchored, ObjectType.WS_GROUP, "Initial creation") History.Note("Element Inserted") self.elements.append(anchored)
def AddCodelet(self, codelet, *, msg="", parents=[]): """Adds codelet to coderack. Removes some existing codelet if needed.""" kLogger.debug("Codelet added: %s", str(codelet.family)) if self._codelet_count == self._max_capacity: self._ExpungeSomeCodelet() self._codelets.add(codelet) self._codelet_count += 1 self._urgency_sum += codelet.urgency roles = {} for k, v in codelet.args.items(): if hasattr(v, "_hid"): roles[v._hid] = "Argument %s" % k History.AddArtefact(codelet, ObjectType.CODELET, msg, parents, roles=roles)
def __init__(self, parent_controller, *, nsteps=5, workspace_arguments=None, parents=None, msg=""): """Initializes the subspace by just storing the arguments.""" self.parent_controller = parent_controller self.nsteps = nsteps self.workspace_arguments = workspace_arguments effective_parents = [parent_controller] if parents: effective_parents.extend(parents) History.AddArtefact(self, ObjectType.SUBSPACE, msg, parents=effective_parents)
def __init__(self, *, msg='', parents=[]): PSFocusable.__init__(self) self.relations = dict() self._span = None History.AddArtefact(self, ObjectType.WS_GROUP, "EltOrGp %s" % msg, parents)