def clone_on_move(self, robot: constants.Robot, robot_position: tuple): new_robots_pos = dict(self.robot_positions) prev_robot_position = new_robots_pos[robot] new_robots_pos[robot] = robot_position new_board = Board(new_robots_pos, self.goal_positions, self.board.copy()) new_board.board[prev_robot_position[0]] = new_board.board[ prev_robot_position[0]].copy() prev_case = new_board.board[prev_robot_position[0]][ prev_robot_position[1]] new_board.board[prev_robot_position[0]][prev_robot_position[1]] = Case( prev_case.i, prev_case.j, prev_case.goal, prev_case.laser, prev_case.walls, None, ) if robot_position[0] != prev_robot_position[0]: new_board.board[robot_position[0]] = new_board.board[ robot_position[0]].copy() new_case = new_board.board[robot_position[0]][robot_position[1]] new_board.board[robot_position[0]][robot_position[1]] = Case( new_case.i, new_case.j, new_case.goal, new_case.laser, new_case.walls, robot) return new_board
def __init__(self, direction, length): self.tete = Case(random.randint(length, 24 - length), random.randint(length, 24 - length)) self.queue = [] for i in range(length - 1): self.queue.append( Case(self.tete.x - (i + 1) * direction[0], self.tete.y - (i + 1) * direction[1]))
def initialize_grid(width, height, nb): #Building the window frame width_pixel = 24 * width height_pixel = 24 * height window = pygame.display.set_mode((width_pixel, height_pixel)) mines = [] score_to_reach = width * height - nb #Building the grid object and placing the mines grid = [] if nb == 0: for i in range(height): line = [] for j in range(width): line.append(Case(i, j, window, "Empty")) grid.append(line) elif nb > width * height: for i in range(height): line = [] for j in range(width): line.append(Case(i, j, window, "RevealedMine")) grid.append(line) else: if width * height > 2 * nb: for i in range(height): line = [] for j in range(width): line.append(Case(i, j, window, "Empty")) grid.append(line) mines_posed = 0 while mines_posed < nb: i = randint(0, height - 1) j = randint(0, width - 1) if grid[i][j].value == "Empty": grid[i][j].set_value("RevealedMine") mines.append({"i": i, "j": j}) mines_posed += 1 else: for i in range(height): line = [] for j in range(width): line.append(Case(i, j, window, "RevealedMine")) grid.append(line) empty_posed = 0 while empty_posed < width * height - nb: i = randint(0, height - 1) j = randint(0, width - 1) if grid[i][j].value == "RevealedMine": grid[i][j].set_value("Empty") empty_posed += 1 #Setting the cases values when next to a mine for line in grid: for case in line: if case.value == "RevealedMine": voisins = neighbors(case.i, case.j, grid) for voisin in voisins: voisin.increment_value()
def case(selector, sources, schedulerOrDefaultSource=None): assert callable(selector) assert isinstance(sources, dict) if schedulerOrDefaultSource == None: return Case(selector, sources, Observable.empty()) elif isinstance(schedulerOrDefaultSource, Scheduler): return Case(selector, sources, Observable.empty(schedulerOrDefaultSource)) else: assert isinstance(schedulerOrDefaultSource, Observable) return Case(selector, sources, schedulerOrDefaultSource)
def creer_labyrinthe_depuis_chaine(chaine): position_du_robot = (0, 0) lab = Labyrinthe() lignes = chaine.split("\n") for i, ligne in enumerate(lignes): for j, c in enumerate(ligne): if c == lab.get_robot(): case = Case(nature=" ", robot=True) position_du_robot = (i, j) else: case = Case(nature=c, robot=False) lab.insert_une_case((i, j), case)
def organize_cases(self): ca = np.array(self.cases) np.random.shuffle(ca) # Randomly shuffle all cases if self.config.scale_input and type(self.config.scale_input[0]) is str and "minmaxcolumns" in \ self.config.scale_input[0]: print("Scaling inputs with minmaxcolumns") labels = ca[:, -1] ca = np.delete(ca, -1, axis=1) # remove label ca = np.apply_along_axis(scale1DArrayMinMax, 1, ca) ca = np.insert(ca, ca.shape[1], labels, axis=1) # Handle case fraction ca = ca[:round(len(ca) * self.case_fraction)] ca = ca.tolist() self.cases = self.cases[:round(len(self.cases) * self.case_fraction)] separator1 = round(len(self.cases) * self.training_fraction) separator2 = separator1 + round( len(self.cases) * self.validation_fraction) self.training_cases = ca[:separator1] self.training_cases = self.createCases(self.training_cases) self.validation_cases = ca[separator1:separator2] self.validation_cases = self.createCases(self.validation_cases) self.testing_cases = ca[separator2:] self.testing_cases = self.createCases(self.testing_cases) if self.config.scale_input and type(self.config.scale_input[0]) is int: print("Scale input to ", self.config.scale_input) for x in self.training_cases: x.input = scaleArray(x.input, self.config.scale_input[0], self.config.scale_input[1]) for x in self.validation_cases: x.input = scaleArray(x.input, self.config.scale_input[0], self.config.scale_input[1]) for x in self.testing_cases: x.input = scaleArray(x.input, self.config.scale_input[0], self.config.scale_input[1]) if self.labels: self.training_cases = [ Case(input=self.training_cases[i], target=self.labels[i]) for i in range(len(self.training_cases)) ] self.training_cases = [ Case(input=case[:-1], target=[case[-1]]) for case in self.training_cases ]
def __init__(self, name, mesh, timestep, staggering, fvSchemes, parallel, fast, fastMesh): self.case = Case(name) self.fast = fast if self.fast: fvSchemes = os.path.join('src/schaerWaves/linearUpwindFast') mesh = fastMesh timestep = 120 self.timing = Timing(18000, 3600, timestep) self.staggering = staggering self.sampleDict = os.path.join('src/schaerWaves/sampleLine') self.dynamicsExecution = DynamicsExecution( self.case, mesh, self.timing, self.staggering, StratifiedThermalField(), os.path.join('src/schaerWaves/Uf'), os.path.join('src/schaerWaves/Exner_init'), os.path.join('src/schaerWaves/environmentalProperties'), os.path.join('src/schaerWaves/thermophysicalProperties'), fvSchemes, os.path.join('src/schaerWaves/fvSolution'), sponge=True, parallel=parallel)
def load_case(filename, name=None, exclude_pattern=".*#.*"): """ Load a Case object from the given file. This assumes a number of names for objects found in the file. """ dat = load_mat(filename, exclude_pattern) if name is None: name = os.path.basename(filename) nodes = dat["userdata/surface/triRep/X"].T inds = dat["userdata/surface/triRep/Triangulation"].T - 1 act, bip = dat["userdata/surface/act_bip"] uni, imp, frc = dat["userdata/surface/uni_imp_frc"] fields = dict(act=act, bip=bip, uni=uni, imp=imp, frc=frc) electric = {} rf = {} other_data = {} for k, v in dat.items(): _, section, *objname = k.split("/", 2) if objname and section in ("electric", "rf"): dobj = rf if section == "rf" else electric dobj[objname[0]] = v else: other_data[k] = v return Case(name, nodes, inds, fields, electric, rf, other_data)
def generate(self): """Generate random cases for the board.""" x, y = self.position sx, sy = self.size self.cases = [ Case([x, y - sy // 2], color=colors.random()) for y in range(sy) ]
def __init__(self, job_group=''): # If job group is not specified, we want latest one if job_group == '': job_group = config.LATEST self.job_group = job_group self._cache = os.path.join(config.CACHEDIR, self.job_group, 'main.pickle') # Attempt to load data from cache if os.path.isfile(self._cache): self.data = pickle.load(open(self._cache, 'rb')) return # Load the actual data self.data = [] for name, meta in config.get_builds(self.job_group).items(): build = meta['build'] rhel = meta['rhel'] tier = meta['tier'] production_log = ProductionLog(self.job_group, name, build) for report in self.pull_reports(name, build): report['tier'] = tier report['distro'] = rhel report['OBJECT:production.log'] = production_log self.data.append(Case(report)) # Dump parsed data into cache pickle.dump(self.data, open(self._cache, 'wb'))
def gen_multi_test_objects_cases(self, test_funcs, random_cleanup=False, need_cleanup=False, src_env=None, no_extra=True): # TODO: merge this method with gen_cases if src_env is None: src_env = Env() rets = list() def _find_next_steps(int_test_funcs, cur_env, exist_steps, old_env): if int_test_funcs: test_func = int_test_funcs[0] rest_func = int_test_funcs[1:] new_env = cur_env.gen_transfer_env(test_func) if no_extra and new_env is not None: # this means current env is okay # python3: new_exist_steps = exist_steps.copy() new_exist_steps = copy.deepcopy(exist_steps) new_exist_steps.append(test_func) _find_next_steps(rest_func, new_env, new_exist_steps, cur_env) else: # sigh, need find a route target_env = list(Env.gen_require_env(test_func)) for tgt_env in self.find_suit_envs(target_env): steps_list = self.compute_route_permutations( cur_env, tgt_env) new_env = tgt_env.gen_transfer_env(test_func) if not new_env: # BUG: this should not happen LOGGER.info('Cannot use env %s for testing', tgt_env) continue for steps in steps_list: # python3: new_exist_steps = exist_steps.copy() new_exist_steps = copy.deepcopy(exist_steps) new_exist_steps.extend(steps) new_exist_steps.append(test_func) _find_next_steps(rest_func, new_env, new_exist_steps, tgt_env) else: # this is the end of the test_funcs # drop last test func final_steps = exist_steps[:-1] if need_cleanup: cleanup_steps = self.gen_cleanups(cur_env, src_env, random_cleanup) else: cleanup_steps = None # pass old_env since we drop last test func rets.append((final_steps, old_env, cleanup_steps)) _find_next_steps(test_funcs, src_env, [], None) for steps, tgt_env, cleanup_steps in rets: tmp_case = self.restore_onigin_data(steps) case_obj = Case(tmp_case, tgt_env=tgt_env, cleanups=cleanup_steps) yield case_obj
def initialiser_tableau(self): """ Initialise le tableau à son contenu initial en suivant les étapes suivantes: 1) On crée chacune des cases du tableau. 2) On y ajoute ensuite les mines dans certaines cases qui sont choisies au hasard. 3) À chaque fois qu'on ajoute une mine dans une case, vous devriez incrémenter dans chacune des cases voisines un attribut qui représentera le nombre de mines voisines pour ces cases. """ for rangee_x in range(1, self.dimension_rangee+1): for colonne_y in range(1, self.dimension_colonne+1): coordonnees = (rangee_x, colonne_y) self.dictionnaire_cases[coordonnees] = Case() nb_mines_placees = 0 while nb_mines_placees < self.nombre_mines: mine_x = randint(1, self.dimension_rangee) mine_y = randint(1, self.dimension_colonne) la_case = self.dictionnaire_cases[(mine_x, mine_y)] # Comme la position de la mine est aléatoire, il est possible que la case soit déjà minée. # Dans ce cas, on recommence! if not la_case.est_minee: la_case.ajouter_mine() nb_mines_placees += 1 for coord_voisin in self.obtenir_voisins(mine_x, mine_y): voisin = self.dictionnaire_cases[coord_voisin] voisin.ajouter_une_mine_voisine()
def __init__(self, url, uname, passwd): super().__init__(url) self.client = APIClient(url) self.client.user = uname self.client.password = passwd # Classes for each endpoint self.attachment = Attachment(self.client) self.case = Case(self.client) self.case_field = CaseField(self.client) self.case_type = CaseType(self.client) self.config = Configuration(self.client) self.milestone = Milestone(self.client) self.plan = Plan(self.client) self.priority = Priority(self.client) self.project = Project(self.client) self.report = Report(self.client) self.result = Result(self.client) self.result_field = ResultField(self.client) self.run = Run(self.client) self.section = Section(self.client) self.status = Status(self.client) self.suite = Suite(self.client) self.template = Template(self.client) self.test = Test(self.client) self.user = User(self.client)
def gen_cases(self, test_func, random_cleanup=False, need_cleanup=False, src_env=None): if not src_env: src_env = Env() target_env = list(Env.gen_require_env(test_func)) for tgt_env in self.find_suit_envs(target_env): cases = self.compute_route_permutations(src_env, tgt_env) if not tgt_env.gen_transfer_env(test_func): LOGGER.info('Cannot use env %s for testing', tgt_env) continue cleanup_steps = None if need_cleanup: new_tgt_env = tgt_env.gen_transfer_env(test_func) cleanups = self.compute_route_permutations( src_env, new_tgt_env, True) if cleanups: if random_cleanup: cleanup_steps = random.choice(cleanups) else: cleanup_steps = min(cleanups) cleanup_steps = self.restore_onigin_data(cleanup_steps) LOGGER.debug("env: %s case num: %d" % (tgt_env, len(cases))) for case in cases: tmp_case = self.restore_onigin_data(case) case_obj = Case(tmp_case, tgt_env=tgt_env, cleanups=cleanup_steps) yield case_obj
def creationCases(self): for i in range(0, 8): self.cases.append([]) for j in range(0, 8): self.cases[i].append(Case(i, j)) print("cases crees :{0}x{1}".format(len(self.cases), len(self.cases[0])))
def __init__(self, name, blockMeshDict, controlDict=os.path.join("src", "controlDict")): self.case = Case(name) self.blockMeshDict = blockMeshDict self.controlDict = controlDict
def createCases(self, list): if self.config.one_hot_output and self.config.one_hot_output[0]: return [ Case(input=unpack(case[:-1]), target=unpack( tft.int_to_one_hot( int(case[-1]), size=self.config.one_hot_output[-1]))) for case in list ] else: return [ Case(input=unpack(case[:-1]), target=unpack(case[-1])) for case in list ]
def __init__(self, name, dx, mesh, timestep, fvSchemesPrimary, fvSchemesGhost, parallel, fast, controlDict=None, solverRule=None): self.case = Case(name) self.dx = dx self.mesh = mesh self.timing = Timing(5, 1, timestep) self.fvSchemesPrimary = fvSchemesPrimary self.fvSchemesGhost = fvSchemesGhost self.fvSolution = os.path.join('src/deformationPlane/fvSolution') self.controlDict = controlDict or os.path.join( 'src/deformationPlane/controlDict.template') self.setGaussiansDict = os.path.join( 'src/deformationPlane/setGaussiansDict') self.deformationalAdvectionDict = os.path.join( 'src/deformationPlane/deformationalAdvectionDict') self.solverRule = solverRule or 'scalarDeformation'
def case(self, **kwargs): """Return a instance of Case object. Args: tcex (TcEx): An instantiated instance of TcEx object. artifacts (Artifact, kwargs): a list of Artifacts corresponding to the Case assignee (Assignee, kwargs): the user or group Assignee object for the Case created_by (User, kwargs): [Read-Only] The **Created By** for the Case. date_added (str, kwargs): [Read-Only] The **Date Added** for the Case. description (str, kwargs): The **Description** for the Case. name (str, kwargs): [Required] The **Name** for the Case. notes (Note, kwargs): a list of Notes corresponding to the Case owner (str, kwargs): The Org/Owner name for the Case. related (Case, kwargs): The **Related** for the Case. resolution (str, kwargs): The **Resolution** for the Case. severity (str, kwargs): [Required] The **Severity** for the Case. status (str, kwargs): [Required] The **Status** for the Case. tags (tcex.case_management.tag.Tag, kwargs): a list of Tags corresponding to the Case (NOTE: Setting this parameter will replace any existing tag(s) with the one(s) specified) tasks (case_management.task.Task, kwargs): a list of Tasks corresponding to the Case user_access (User, kwargs): a list of Users that, when defined, are the only ones allowed to view or edit the Case workflow_events (WorkflowEvent, kwargs): The **Events** for the Case. workflow_template (WorkflowTemplate, kwargs): the Template that the Case is populated by. xid (str, kwargs): The **Xid** for the Case. """ return Case(self.tcex, **kwargs)
def avance(self, direction, pomme): # D'abord on calcule les nouvelles coordonnées de la tête new_tete_x = self.tete.x + direction[0] new_tete_y = self.tete.y + direction[1] # Puis on détermine si la tête va être sur la même case que la pomme (le serpent mange la pomme) mange_pomme = pomme.x == new_tete_x and pomme.y == new_tete_y if mange_pomme: # Si le serpent mange la pomme on ajoute une écaille au serpent self.queue.append( Case(0, 0) ) # On la met en (0,0) car elle prendra les coords de la dernière case # La liste des index inversés dans la queue du serpent index_list = reversed(range(self.longueur() - 1)) # C'est à dire qu'on part de la dernière écaille et on remonte jusqu'à la première for index in index_list: if index == 0: # Première écaille (en dernier dans la liste), elle prend les coords de la tête self.queue[index].x = self.tete.x self.queue[index].y = self.tete.y else: # Toutes les autres écaille prennent les coords de l'écaille qui la précède self.queue[index].x = self.queue[index - 1].x self.queue[index].y = self.queue[index - 1].y # Enfin, la tête prend ses nouvelles coords self.tete.x = new_tete_x self.tete.y = new_tete_y return mange_pomme
def __init__(self, name, mountainHeight, mesh, timestep, fvSchemes, parallel, fast): self.case = Case(name) self.mountainHeight = mountainHeight self.fast = fast if fast: timing = Timing(500, 500, timestep) else: timing = Timing(21600, 10800, timestep) self.dynamicsExecution = DynamicsExecution( self.case, mesh, timing, Lorenz.dynamics(os.path.join('src/resting/theta_init')), StratifiedThermalField(), os.path.join('src/resting/Uf'), os.path.join('src/resting/Exner_init'), os.path.join('src/resting/environmentalProperties'), os.path.join('src/resting/thermophysicalProperties'), fvSchemes, os.path.join('src/resting/fvSolution'), sponge=False, parallel=parallel)
def gen_cases_special(self, src_env, start_env, end_env): """ Support find cases reach mutli target env """ # TODO: this is tied to mist to close for tgt_start_env in self.find_suit_envs(start_env): if tgt_start_env == src_env: cases = None else: cases = self.compute_route_permutations(src_env, tgt_start_env) if not cases: continue for tgt_end_env in self.dep_graph[tgt_start_env].keys(): if end_env <= tgt_end_env: funcs = self.dep_graph[tgt_start_env][tgt_end_env] if cases: for data in itertools.product(cases, funcs): case = list(data[0]) case = self.restore_onigin_data(case) case.append(data[1]) case_obj = Case(case, tgt_env=tgt_end_env) yield case_obj else: for func in funcs: case_obj = Case([func], tgt_env=tgt_end_env) yield case_obj
class BoxedBoard(cqparts.Assembly): clearance = PositiveFloat(12) case = Case(thickness=3, height=30, screw=Screw) # board = Pizero() board = PartRef(PizeroBoard) def initialize_parameters(self): self.coll = [] def make_components(self): board = self.board() bb = board.bounding_box items = {"case": self.case, "board": board} # modify the box to fit the board self.case.length = board.length + 2 * self.clearance self.case.width = board.width + 2 * self.clearance self.case.explode = 0.0 self.case.screw.length = PositiveFloat(15.0) return items def make_constraints(self): constraints = [ Fixed(self.components["case"].mate_origin), Fixed(self.components["board"].mate_origin), ] return constraints
def calculateSigmaThroughInterpolation(caseList, Re): ''' Creates, through interpolation new result for a given Re accepts caseList for a given alfa ''' S = [ 0.01, 0.025, 0.04, 0.055, 0.07, 0.085, 0.1, 0.115, 0.13, 0.145, 0.16, 0.175, 0.19, 0.205, 0.22, 0.235, 0.25 ] caseList.sort(key=lambda l: l.alfa) out = [] for key, group in groupby(caseList, lambda x: x.alfa): alist = list(group) case = Case() case.alfa = alist[0].alfa case.Re = Re stab = [] sigma = [] for s in S: # try: sig = calculateSigmaForS(alist, s, Re) sigma.append(sig) stab.append(s) # except: # print "Failed for:" # print "Alfa=" + str(case.alfa) + " S=" + str(s) # continue case.S = stab case.sigma = sigma out.append(case) return out
def parse_unseparated(resources_and_tests): top_level_suite = Suite(name="Top level suite") resources = [] sequence = 1 args_are_resources = True for test_or_resource in resources_and_tests: # Test for suites or test cases. try: if looks_like_a_suite(test_or_resource): parsed_suite = parse_yaml_suite(test_or_resource, parent=top_level_suite, sequence=sequence) top_level_suite.append_test(parsed_suite) args_are_resources = False sequence = sequence + 1 elif looks_like_a_case(test_or_resource): case = Case(test_or_resource, parent=top_level_suite, sequence=sequence) top_level_suite.append_test(case) sequence = sequence + 1 elif args_are_resources: resources.append(test_or_resource) else: sys.exit(test_or_resource + " does not appear to be a" " test case or suite")
def __init__(self, name, dx, mountainHeight, mesh, staggering, tracerFieldDict, velocityFieldDict, timing, fvSchemes, parallel, fast, controlDict=Paths.defaultControlDict, solverRule=None): self.case = Case(name) self.dx = dx self.mountainHeight = mountainHeight self.mesh = mesh self.staggering = staggering self.tracerFieldDict = tracerFieldDict self.velocityFieldDict = velocityFieldDict self.timing = timing self.fvSchemes = fvSchemes self.fvSolution = os.path.join('src/fvSolution') self.controlDict = controlDict self.parallel = parallel self.fast = fast self.solverRule = solverRule or self.staggering.advectionSolverRule self.solverDependencies = [ self.case.path('0', staggering.T), self.case.path('0/phi')] + \ self.staggering.advectionSolverDependencies(self.case)
def __init__(self, minesCnt, dimensions): self.width = dimensions[0] # larg self.height = dimensions[1] # long self.minesCnt = minesCnt self.field = [[Case((x, y), 'safe') for x in range(self.width)] for y in range(self.height)] self.mines = []
def create_case(self, name=None, replace=False): """ Create a new Case in the history. Attributes: name (Optional[str]): Name of Case being created. Default to *None* (in this case name is auto-assigned to Case). replace (Optional[bool]): Specifies if *current* Case should be replaced (*True*) or kept (*False*). Defaults to *False*. Returns: Case: New Case. Note: New Case becomes a *current* one; previous *current* Case is added to the list of *run* Cases (if `replace` is *False*) or replaced by new one (if `replace` is *True*). """ if not name: idx = self.nb_cases if replace else self.nb_cases + 1 name = "Case_{}".format(idx) case = Case(name) self.insert_case(case, replace) return case
def __init__(self): self.grille = [] for i in range(9): for j in range(9): self.grille.append(Case(i, j)) self.savegrille = copy.deepcopy(self.grille) self.vtest = []
def build_grid(nb_rows, nb_cols): grid = [] for i in range(nb_rows): line = [] for j in range(nb_cols): line.append(Case(i, j)) grid.append(line) return grid