def test_run(self, target, barcode, kernel, rootfs, test, task_id): """@todo: Docstring for test_run :arg1: @todo :returns: @todo """ cmd,timeout,test_case=( test['cmd'], test['timeout'], test['test_case'] ) try: _, out = target.run(cmd, timeout=20) except Exception as e: raise out = "we hit an exception, reboot the target" target.vlm.unreserve_target() target = Target(barcode, kernel, rootfs) target.login(deploy=False) finally: log_dir='logs/{}_{}'.format(barcode,task_id) if not os.path.exists(log_dir): os.makedirs(log_dir) log_file = "{}.log".format(test_case) log=os.path.join(log_dir,log_file) log = Logging(log) log(out) return out
def __init__(self, name, srcs, deps, outs, cmd, blade, kwargs): """Init method. Init the gen rule target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) outs = var_to_list(outs) Target.__init__(self, name, 'gen_rule', srcs, deps, blade, kwargs) self.data['outs'] = outs self.data['cmd'] = cmd
def __init__(self, name, srcs, deps, outs, cmd, blade, kwargs): """Init method. Init the gen rule target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) outs = var_to_list(outs) Target.__init__(self, name, 'gen_rule', srcs, deps, None, blade, kwargs) self.data['outs'] = outs self.data['locations'] = [] self.data['cmd'] = location_re.sub(self._process_location_reference, cmd)
def __init__(self, name, type, srcs, deps, resources, source_encoding, warnings, kwargs): """Init method. Init the java jar target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) resources = var_to_list(resources) Target.__init__(self, name, type, srcs, deps, None, blade.blade, kwargs) self._process_resources(resources) self.data['source_encoding'] = source_encoding if warnings is not None: self.data['warnings'] = var_to_list(warnings)
def __init__(self, name, srcs, deps, type, out, blade, kwargs): srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, 'package', [], deps, None, blade, kwargs) if type not in _package_types: console.error_exit('%s: Invalid type %s. Types supported ' 'by the package are %s' % ( self.fullname, type, ', '.join(sorted(_package_types)))) self.data['type'] = type self.data['sources'], self.data['locations'] = [], [] self._process_srcs(srcs) if not out: out = '%s.%s' % (name, type) self.data['out'] = out
def __init__(self, name, type, srcs, deps, base, visibility, kwargs): """Init method. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, type, srcs, deps, visibility, blade.blade, kwargs) if base: if not base.startswith('//'): console.error_exit('%s: Invalid base directory %s. Option base should ' 'be a directory starting with \'//\' from BLADE_ROOT directory.' % (self.fullname, base)) self.data['python_base'] = base[2:] self.data['python_sources'] = [self._source_file_path(s) for s in srcs]
def test_aggregation(): # note: uneven aggregation: we only want 1 resulting metric, query = Query("") query["avg_by"] = {"server": [""]} query["sum_by"] = {"type": [""]} targets = { "web1.db": {"id": "web1.db", "tags": {"server": "web1", "type": "db", "n3": "foo"}}, "web1.php": {"id": "web1.php", "tags": {"server": "web1", "type": "php", "n3": "foo"}}, "web2.db": {"id": "web2.db", "tags": {"server": "web2", "type": "db", "n3": "foo"}}, "web2.php": {"id": "web2.php", "tags": {"server": "web2", "type": "php", "n3": "foo"}}, "web2.memcache": {"id": "web2.memcache", "tags": {"server": "web2", "type": "memcache", "n3": "foo"}}, } from pprint import pprint for (k, v) in targets.items(): v = Target(v) v.get_graph_info(group_by={}) targets[k] = v graphs, _query = build_graphs_from_targets(targets, query) # TODO: there should be only 1 graph, containing all 5 items print "Graphs:" for (k, v) in graphs.items(): print "graph key" pprint(k) print "val:" pprint(v) assert {} == graphs
def __init__(self, name, srcs, deps, prebuilt, blade, kwargs): """Init method. Init the java jar target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, 'java_jar', srcs, deps, blade, kwargs) if prebuilt: self.data['type'] = 'prebuilt_java_jar' self.java_jar_cmd_list = [] self.cmd_var_list = [] self.java_jar_after_dep_source_list = [] self.targets_dependency_map = {} self.java_jar_dep_vars = {} self.java_jars_map = self.blade.get_java_jars_map() self.sources_dependency_map = self.blade.get_sources_explict_dependency_map()
def main(): parameter_store = ParameterStore(DEPLOYMENT_ACCOUNT_REGION, boto3) deployment_map = DeploymentMap(parameter_store, os.environ["ADF_PIPELINE_PREFIX"]) s3 = S3(DEPLOYMENT_ACCOUNT_REGION, boto3, S3_BUCKET_NAME) sts = STS(boto3) role = sts.assume_cross_account_role( 'arn:aws:iam::{0}:role/{1}-org-access-adf'.format( MASTER_ACCOUNT_ID, parameter_store.fetch_parameter('cross_account_access_role')), 'pipeline') organizations = Organizations(role) clean(parameter_store, deployment_map) for p in deployment_map.map_contents.get('pipelines'): pipeline = Pipeline(p) for target in p['targets']: target_structure = TargetStructure(target) for step in target_structure.target: for path in step.get('path'): try: regions = step.get( 'regions', p.get('regions', DEPLOYMENT_ACCOUNT_REGION)) pipeline.stage_regions.append(regions) pipeline_target = Target(path, regions, target_structure, organizations) pipeline_target.fetch_accounts_for_target() except BaseException: raise Exception( "Failed to return accounts for {0}".format(path)) pipeline.template_dictionary["targets"].append( target_structure.account_list) if DEPLOYMENT_ACCOUNT_REGION not in regions: pipeline.stage_regions.append(DEPLOYMENT_ACCOUNT_REGION) parameters = pipeline.generate_parameters() pipeline.generate() deployment_map.update_deployment_parameters(pipeline) s3_object_path = upload_if_required(s3, pipeline) store_regional_parameter_config(pipeline, parameter_store) cloudformation = CloudFormation( region=DEPLOYMENT_ACCOUNT_REGION, deployment_account_region=DEPLOYMENT_ACCOUNT_REGION, role=boto3, template_url=s3_object_path, parameters=parameters, wait=True, stack_name="{0}-{1}".format(os.environ["ADF_PIPELINE_PREFIX"], pipeline.name), s3=None, s3_key_path=None) cloudformation.create_stack()
def __init__(self, name, target_type, srcs, deps, warning, defs, incs, export_incs, optimize, extra_cppflags, extra_linkflags, blade, kwargs): """Init method. Init the cc target. """ srcs_list = var_to_list(srcs) srcs = [] for item in srcs_list: if (';' in item): # file list expanded with asterisk wildcard file_name_array = string.split(item, ';') for file_name in file_name_array: srcs.append(file_name) else: srcs.append(item) deps = var_to_list(deps) defs = var_to_list(defs) incs = var_to_list(incs) export_incs = var_to_list(export_incs) opt = var_to_list(optimize) extra_cppflags = var_to_list(extra_cppflags) extra_linkflags = var_to_list(extra_linkflags) Target.__init__(self, name, target_type, srcs, deps, blade, kwargs) self.data['warning'] = warning self.data['defs'] = defs # add by zxy([email protected]) 20140929 support absolute include path (/common/gsl/include) for index, item in enumerate(incs): if (item.startswith('/')): incs[index] = find_relative_path(self.path, item) #end self.data['incs'] = incs self.data['export_incs'] = export_incs self.data['optimize'] = opt self.data['extra_cppflags'] = extra_cppflags self.data['extra_linkflags'] = extra_linkflags self._check_defs() self._check_incorrect_no_warning()
def __init__(self): """intialize the game, and create resources""" pygame.init() self.settings = Settings() #Set the window size and caption self.screen = pygame.display.set_mode( (self.settings.screen_width, self.settings.screen_height)) pygame.display.set_caption("Target Practice") #create an instance to store game statistics self.stats = GameStats(self) #import the rocket ship and make an instance of it self.rocketShip = RocketShip(self) #import the orb self.orbs = pygame.sprite.Group() #import the target self.target = Target(self) #Create a play button self.play_button = Button(self, "Play") #misses self.miss = 0
def test_agg_key(): t = Target({ 'variables': { 'foo': 'bar', 'target_type': 'rate', 'region': 'us-east-1' }}) # catchall bucket assert t.get_agg_key({'foo': ['']}) == 'foo:__region=us-east-1,target_type=rate' # non catchall bucket assert t.get_agg_key({'foo': ['ba', ''], 'bar': ['']}) == 'foo:ba__region=us-east-1,target_type=rate' struct = { 'n3': ['bucketmatch1', 'bucketmatch2'], 'othertag': [''] } # none of the structs applies assert t.get_agg_key(struct) == '__foo=bar,region=us-east-1,target_type=rate' struct = { 'target_type': [''], 'region': ['us-east', 'us-west', ''] } # one catchall, the other matches assert t.get_agg_key(struct) == 'region:us-east,target_type:__foo=bar'
def __init__(self, name, srcs, deps, type, out, shell, blade, kwargs): srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, 'package', [], deps, None, blade, kwargs) if type not in _package_types: console.error_exit('%s: Invalid type %s. Types supported ' 'by the package are %s' % ( self.fullname, type, ', '.join(sorted(_package_types)))) self.data['type'] = type self.data['sources'], self.data['locations'] = [], [] self._process_srcs(srcs) if not out: out = '%s.%s' % (name, type) self.data['out'] = out self.data['shell'] = shell
def _create_target(self, num, row_number): target = Target(self) target_width, target_height = target.rect.size target.x = target_width+2 * target_width * num target.rect.x = target.x target.rect.y = target.rect.height + 2 * target.rect.height * row_number self.targets.add(target)
def setUp(self) -> None: """Сохраняет ссылки на нужные объекты, откатывает их к первоначальному состоянию :return: None """ # Две цели first_target = Target(number=1, coordinates=np.array([100000, 1001, 30000.]), velocities=np.array([-50., 0., -60.])) second_target = Target(number=2, coordinates=np.array([30000, 5001, 30000.]), velocities=np.array([-50., 0., -60.])) # Список целей self.target_list = [first_target, second_target] # Два локатора first_radar = MultiFunctionalRadar(target_list=self.target_list, stable_point=np.array( [1001, 0, -780]), mfr_number=1) second_radar = MultiFunctionalRadar(target_list=self.target_list, stable_point=np.array( [-1000, 0, 780]), mfr_number=2) # Список локаторов self.radar_list = [first_radar, second_radar] # Собственный ПБУ self.command_post = CommandPost(mfr_list=self.radar_list) self.failure_msg = "Что-то пошло не так"
def run_game(): """Initialize game, create window object.""" pygame.init() # NOTE: Initialize a pygame instance. ai_settings = Settings() # Screen settings. screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height)) # Add title to window. pygame.display.set_caption('Alien Invasion') # Draw button. play_button = Button(ai_settings, screen, "Play") # Make a ship. ship = Ship(ai_settings, screen) # Make bullets. bullets = Group() # Make target target = Target(ai_settings, screen) # Create the fleet of . # gf.create_fleet(ai_settings, screen, ship) # Initalize stats for a new game stats = GameStats(ai_settings) # Start the run loop for our game. while True: gf.check_events(ai_settings, screen, ship, bullets, stats, play_button) if stats.game_active: ship.update() target.update() gf.update_target(ai_settings, screen, target, bullets) gf.update_bullets(ai_settings, screen, ship, bullets, target, stats, play_button) gf.update_screen(ai_settings, screen, ship, bullets, stats, play_button, target)
def calculate_checkpoints(self): goal = Vec3(0.0, 5125.0, 0.0) ball_to_target = Line(goal, self.S.ball_location) self.D.draw_line(ball_to_target) car_to_ball = Line(self.S.car_location, self.S.ball_location) self.D.draw_line(car_to_ball) hit_prep = ball_to_target.get_point_on_line(1.2) hit_prep.z = 0 car_to_hit_prep = Line(self.S.car_location, hit_prep) target = Target(location=hit_prep) self.checkpoints.append(target) ball = Target(location=self.S.ball_location) self.checkpoints.append(target) print([check.location for check in self.checkpoints]) # if car_to_hit_prep is not mostly straight, target hit prep # angle_diff = abs(ball_to_target.angle_difference(car_to_hit_prep)) # print(angle_diff) # if angle_diff < 2: # print("GOFORIT") # self.go = True # planned_location = self.S.ball_location # else: planned_location = hit_prep # self.go = False # print("not yet") # # plan = Line(self.S.car_location, planned_location) # self.D.draw_line(plan, color="orange") return Target(location=planned_location)
def __init__(self, name, srcs, deps, prebuilt, blade, kwargs): """Init method. Init the java jar target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, 'java_jar', srcs, deps, blade, kwargs) if prebuilt: self.type = 'prebuilt_java_jar' self.data['jar_class_path'] = self._prebuilt_java_jar_src_path() self.data['java_jars'] = [] self.java_jar_cmd_list = [] self.cmd_var_list = [] self.java_jar_after_dep_source_list = [] self.targets_dependency_map = {} self.java_jar_dep_vars = {}
def create_target(self): """ Creates a new target of a random type and adds it to the list. :return: """ # TODO: Decide what type of target to create and append it to the list #randomly select a number from 1 to 3 num = random.uniform(0, 3) #if the number is 1 the new target is a standard target if num <= 1: new = Target() #if the number is 2 the new target is a strong target elif num <= 2: new = Strong() #if the number is 3 the new target is a safe target elif num <= 3: new = Safe() #if we get anything else create standard target else: new = Target() #add new target to list of targets self.targets.append(new) # create a 1 in 20 chance of creating a UFO if (random.uniform(0, 20) <= 1): ufo = UFO() self.targets.append(ufo)
def getTarget(self, target_name=None, password=None): # Override self.target_name if set if not target_name: target_name = self.target_name # TODO: Controllare anche che il master sia connesso. Se e' configurato ma non connesso si deve solo connettere. Il problema e' che non c'e' modo di sapere se effettivamente e' connesso if not self.master: print("Connecting to master") # The first parameter as False creates a Master target self.master = Target(False, self.protocol, self.address, self.port, target_name) # TODO: Serve lo stato del master per capire se e' gia' connesso (e quindi ci si riconnette) oppure se serve una nuova connessione if self.master.is_connected or self.master.connect(password): print("Connected to master") else: print("Error while connecting to master") return False print("Connecting to slave") self.slave = self.master.getSlave(target_name) if self.slave and ( not self.slave.is_connected) and self.slave.connect(): print("Connected to slave") else: print("Error while connecting to the slave target") return self.slave
def connectTarget(ip, port): target = Target(ip, int(port)) target.secureConnect() if target.isConnected(): return target else: return False
def __init__(self, name, target_type, srcs, deps, warning, defs, incs, export_incs, optimize, extra_cppflags, extra_linkflags, blade, kwargs): """Init method. Init the cc target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) defs = var_to_list(defs) incs = var_to_list(incs) export_incs = var_to_list(export_incs) opt = var_to_list(optimize) extra_cppflags = var_to_list(extra_cppflags) extra_linkflags = var_to_list(extra_linkflags) Target.__init__(self, name, target_type, srcs, deps, blade, kwargs) self.data['warning'] = warning self.data['defs'] = defs self.data['incs'] = incs self.data['export_incs'] = export_incs self.data['optimize'] = opt self.data['extra_cppflags'] = extra_cppflags self.data['extra_linkflags'] = extra_linkflags self._check_defs() self._check_incorrect_no_warning()
def generateTarget(self): while True: x,y=randint(2,self.GRIDS_X-3),randint(2,self.GRIDS_Y-3) if self.grid[y][x] == 0: self.target = Target(x,y,True) self.grid[y][x] = self.target break
def get_data_from_csv(name_of_file): """ Parse the file containing all the information :return: a list of target objects """ res = [] with open(name_of_file, 'r') as f: reader = csv.reader(f) # skip the first line (header) next(reader) for row in reader: data = row[0].split() if data[11] == "Damaging": res.append(Target(data)) elif data[11] == "Probably": data[11] = data[11] + " " + data[12] del data[12] res.append(Target(data)) elif data[11] == "Potentially": data[11] = data[11] + " " + data[12] del data[12] res.append(Target(data)) elif data[11] == "Unknown": res.append(Target(data)) return res
def test_fetch_accounts_for_target_account_id(): cls = Target(path='12345678910', regions=['region1', 'region2'], target_structure=MockTargetStructure(), organizations=None) with patch.object(cls, '_target_is_account_id') as mock: cls.fetch_accounts_for_target() mock.assert_called_once_with()
def __init__(self, fname, *args, **kwargs): self.pass_filename = kwargs.get('pass_filename', False) if 'pass_filename' in kwargs: del kwargs['pass_filename'] Target.__init__(self, *args, **kwargs) if self.pass_filename: self.passes = 1 self.filename = fname
def test_fetch_account_error(): cls = Target(path='some_string', regions=['region1', 'region2'], target_structure=MockTargetStructure(), organizations=Mock(), step_name=None) with raises(InvalidDeploymentMapError): cls.fetch_accounts_for_target()
def __init__(self): self.reset = False self.quit = False self.time_inc = .1 self.time = 0 self.bal = 0 self.target = Target() self.cmd_list = ["dstab", "wait", "quit", "reset"]
def targets(img, readText=False): # Edge detection modimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) modimg = cv2.GaussianBlur(img, (5, 5), 0) modimg = cv2.Canny(img, 100, 200) # Find contours contImg, contours, _ = cv2.findContours(modimg, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # Find squares squares = [] for c in contours: contour_length = cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, 0.02 * contour_length, True) if 4 <= len(approx) <= 6: (x, y, w, h) = cv2.boundingRect(approx) aspectRatio = w / float(h) area = cv2.contourArea(c) hullArea = cv2.contourArea(cv2.convexHull(c)) solidity = area / float(hullArea) checkDimensions = w > 25 and h > 25 checkSolidity = solidity > 0.95 checkAspectRatio = 0.5 <= aspectRatio <= 1.5 if checkDimensions and checkSolidity and checkAspectRatio: s = Square(c, x, y, w, h) if s not in squares: squares.append(s) # print "Added %s" %s # Reject similar squares for s1, s2 in itertools.combinations(squares, 2): if s1.similar(s2) and s2 in squares: squares.remove(s2) # print "Removed %s" %s2 # Find targets targets = [] for s1, s2 in itertools.combinations(squares, 2): if s1.concentric(s2): t = Target(s1, s2) if t not in targets: targets.append(t) # print "Found %s" %t # Read text inside targets if readText == True: for t in targets: t.readText(img) # print "Total number of squares: %s" %(len(squares)) # print "Total number of targets: %s" %(len(targets)) return targets
def worker_thread(p, organizations, auto_create_repositories, s3, deployment_map, parameter_store): pipeline = Pipeline(p) if auto_create_repositories == 'enabled': try: code_account_id = next(param['SourceAccountId'] for param in p['params'] if 'SourceAccountId' in param) has_custom_repo = bool( [item for item in p['params'] if 'RepositoryName' in item]) if auto_create_repositories and code_account_id and str( code_account_id).isdigit() and not has_custom_repo: repo = Repo(code_account_id, p.get('name'), p.get('description')) repo.create_update() except StopIteration: LOGGER.debug( "No need to create repository as SourceAccountId is not found in params" ) for target in p.get('targets', []): target_structure = TargetStructure(target) for step in target_structure.target: for path in step.get('path'): regions = step.get('regions', p.get('regions', DEPLOYMENT_ACCOUNT_REGION)) step_name = step.get('name') params = step.get('params', {}) pipeline.stage_regions.append(regions) pipeline_target = Target(path, regions, target_structure, organizations, step_name, params) pipeline_target.fetch_accounts_for_target() pipeline.template_dictionary["targets"].append( target_structure.account_list) if DEPLOYMENT_ACCOUNT_REGION not in regions: pipeline.stage_regions.append(DEPLOYMENT_ACCOUNT_REGION) parameters = pipeline.generate_parameters() pipeline.generate() deployment_map.update_deployment_parameters(pipeline) s3_object_path = upload_pipeline(s3, pipeline) store_regional_parameter_config(pipeline, parameter_store) cloudformation = CloudFormation( region=DEPLOYMENT_ACCOUNT_REGION, deployment_account_region=DEPLOYMENT_ACCOUNT_REGION, role=boto3, template_url=s3_object_path, parameters=parameters, wait=True, stack_name="{0}-{1}".format(ADF_PIPELINE_PREFIX, pipeline.name), s3=None, s3_key_path=None, account_id=DEPLOYMENT_ACCOUNT_ID) cloudformation.create_stack()
def test_fetch_accounts_for_approval(): cls = Target(path='approval', regions=['region1', 'region2'], target_structure=MockTargetStructure(), organizations=None, step_name=None) with patch.object(cls, '_target_is_approval') as mock: cls.fetch_accounts_for_target() mock.assert_called_once_with()
def __init__(self, name, srcs, deps, prebuilt, blade, kwargs): """Init method. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, 'py_binary', srcs, deps, blade, kwargs) if prebuilt: self.data['type'] = 'prebuilt_py_binary'
def main(): #pylint: disable=R0915 LOGGER.info('ADF Version %s', ADF_VERSION) LOGGER.info("ADF Log Level is %s", ADF_LOG_LEVEL) parameter_store = ParameterStore(DEPLOYMENT_ACCOUNT_REGION, boto3) deployment_map = DeploymentMap(parameter_store, ADF_PIPELINE_PREFIX) s3 = S3(DEPLOYMENT_ACCOUNT_REGION, S3_BUCKET_NAME) sts = STS() role = sts.assume_cross_account_role( 'arn:aws:iam::{0}:role/{1}-readonly'.format( MASTER_ACCOUNT_ID, parameter_store.fetch_parameter('cross_account_access_role')), 'pipeline') organizations = Organizations(role) clean(parameter_store, deployment_map) for p in deployment_map.map_contents.get('pipelines'): pipeline = Pipeline(p) for target in p.get('targets', []): target_structure = TargetStructure(target) for step in target_structure.target: for path in step.get('path'): regions = step.get( 'regions', p.get('regions', DEPLOYMENT_ACCOUNT_REGION)) step_name = step.get('name') params = step.get('params', {}) pipeline.stage_regions.append(regions) pipeline_target = Target(path, regions, target_structure, organizations, step_name, params) pipeline_target.fetch_accounts_for_target() pipeline.template_dictionary["targets"].append( target_structure.account_list) if DEPLOYMENT_ACCOUNT_REGION not in regions: pipeline.stage_regions.append(DEPLOYMENT_ACCOUNT_REGION) parameters = pipeline.generate_parameters() pipeline.generate() deployment_map.update_deployment_parameters(pipeline) s3_object_path = upload_pipeline(s3, pipeline) store_regional_parameter_config(pipeline, parameter_store) cloudformation = CloudFormation( region=DEPLOYMENT_ACCOUNT_REGION, deployment_account_region=DEPLOYMENT_ACCOUNT_REGION, role=boto3, template_url=s3_object_path, parameters=parameters, wait=True, stack_name="{0}-{1}".format(ADF_PIPELINE_PREFIX, pipeline.name), s3=None, s3_key_path=None, account_id=DEPLOYMENT_ACCOUNT_ID) cloudformation.create_stack()
def __init__(self, name, srcs, deps, prebuilt, blade, kwargs): """Init method. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, 'py_egg', srcs, deps, None, blade, kwargs) if prebuilt: self.type = 'prebuilt_py_egg'
def task_run(self, barcode, kernel, rootfs, plan, task_id): """@todo: Docstring for task_run :returns: @todo """ target = Target(barcode, kernel, rootfs) target.login(deploy=True) for test in plan: self.test_run(target, barcode, kernel, rootfs, test, task_id) target.vlm.unreserve_target()
def test_fetch_account_error_invalid_account_id(): cls = Target( path='12345678910', #11 digits rather than 12 (invalid account id) regions=['region1', 'region2'], target_structure=MockTargetStructure(), organizations=Mock(), step_name=None) with raises(InvalidDeploymentMapError): cls.fetch_accounts_for_target()
def add_process(self, **kwargs): """ Adds a new process to the solver. Adds a new process to the solver. The process data is passed with keyword arguments. Parameters ---------- type : string one of "EFFECTIVE", "MOMENTUM", "EXCITATION", "IONIZATION" or "ATTACHMENT". target : string the target species of the process (e.g. "O", "O2"...). ratio : float the ratio of the electron mass to the mass of the target (for elastic/momentum reactions only). threshold : float the energy threshold of the process in eV (only for inelastic reactions). data : array or array-like cross-section of the process array with two columns: column 0 must contain energies in eV, column 1 contains the cross-section in square meters for each of these energies. Returns ------- process : :class:`process.Process` The process that has been added. Examples -------- >>> import numpy as np >>> from bolos import solver, grid >>> grid.LinearGrid(0, 60., 400) >>> solver = BoltzmannSolver(grid) >>> # This is an example cross-section that decays exponentially >>> energy = np.linspace(0, 10) >>> cross_section = 1e-20 * np.exp(-energy) >>> solver.add_process(type="EXCITATION", target="Kriptonite", >>> ratio=1e-5, threshold=10, >>> data=np.c_[energy, cross_section]) See Also -------- load_collisions : Add a set of collisions. """ proc = Process(**kwargs) try: target = self.target[proc.target_name] except KeyError: target = Target(proc.target_name) self.target[proc.target_name] = target target.add_process(proc) return proc
def __init__(self, name, srcs, deps, testdata, kwargs): srcs = var_to_list(srcs) deps = var_to_list(deps) testdata = var_to_list(testdata) Target.__init__(self, name, 'sh_test', srcs, deps, None, blade.blade, kwargs) self._process_test_data(testdata)
def main(): # total number of interactions between 1 and infinity validInter = False # flag for a valid user input while validInter == False: try: totalInter = int(input("Enter total number of interactions (greater than or equal to 1): ")) except ValueError: print("Do not enter non-numeric values.") else: if (totalInter >= 1): validInter = True else: validInteractions = False print("Input is out of range.") # Set the target's probability of X or Y validProb = False # flag for a valid user input while validProb == False: try: probX = int(input("Probability of X-type Interactions for the target (1-100): ")) except ValueError: print("Do not enter non-numeric values.") else: if (1 <= probX <= 100): validProb = True else: validProb = False print("Input is out of range.") probY = 100 - probX # probabilty of Y interactions #DEBUG DEBUG.dprint("total # interactions: %r" % totalInter) DEBUG.dprint("probability of X: %r" % probX) # Pursuer class takes the two probabilities aPursuer = Pursuer(totalInter) aTarget = Target(probX, probY) # Main Loop i = 0 # flag while i < totalInter: # create an interaction for the pursuer and the target interP = aPursuer.createInteraction() interT = aTarget.createInteraction() # DEBUG DEBUG.dprint("aPursuer Interaction: %r" % interP) DEBUG.dprint("aTarget Interaction: %r" % interT) DEBUG.dprint("i: %r" % i) # record and display the result result = aPursuer.reportInteraction(interP, interT) print(result) i += 1 # update flag if i >= 2: aPursuer.adaptBehaviour(interP, interT) targetX, targetY = aTarget.reportEnd() aPursuer.reportEnd(targetX, targetY)
def main (): #Introduction print ("This program uses a cannonball to shoot at a target.") #Create graphics window win = GraphWin(200, 200) win.setCoords(0.0, 0.0, 25.0, 25.0) target = Target(win) flag = False targetHit = False while not flag: #Get inputs print () a = eval(input("Enter the launch angle in degrees: ")) v = eval(input("Enter the initial velocity in meters per second: ")) h = eval(input("Enter the initial height in meters: ")) #Create tracker projectile = Projectile(a, v, h) tracker = Tracker(win, projectile) time = 0.0 while projectile.getY() >= -5: time += .0005 projectile.update(time) tracker.update() #Calculate if cannonball hit target points = target.points() center = tracker.circ.getCenter() center_x = center.getX() center_y = center.getY() radius = tracker.circ.getRadius() for point in points: x = point.getX() y = point.getY() square_dist = (center_x-x) ** 2 + (center_y-y) ** 2 if square_dist <= radius ** 2: targetHit = True if targetHit: print ("\nYou hit the target!") flag = True else: flag = False print ("\nTry again!") #Close window win.getMouse() win.close()
def __init__(self, name, target_type, srcs, deps, warning, defs, incs, export_incs, optimize, extra_cppflags, extra_linkflags, install_dir, extra_cmds, blade, kwargs): """Init method. Init the cc target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) defs = var_to_list(defs) incs = var_to_list(incs) export_incs = var_to_list(export_incs) opt = var_to_list(optimize) extra_cppflags = var_to_list(extra_cppflags) extra_linkflags = var_to_list(extra_linkflags) extra_cmds = var_to_list(extra_cmds) Target.__init__(self, name, target_type, srcs, deps, blade, kwargs) self.data['warning'] = warning self.data['defs'] = defs self.data['incs'] = incs self.data['export_incs'] = export_incs self.data['optimize'] = opt self.data['extra_cppflags'] = extra_cppflags self.data['extra_linkflags'] = extra_linkflags self.data['install_dir'] = install_dir self.data['extra_cmds'] = extra_cmds self._check_defs() self._check_incorrect_no_warning()
def getTarget(self, target_name = None, password = None): # Override self.target_name if set if not target_name: target_name = self.target_name # TODO: Controllare anche che il master sia connesso. Se e' configurato ma non connesso si deve solo connettere. Il problema e' che non c'e' modo di sapere se effettivamente e' connesso if not self.master: print("Connecting to master") # The first parameter as False creates a Master target self.master = Target(False, self.protocol, self.address, self.port, target_name) # TODO: Serve lo stato del master per capire se e' gia' connesso (e quindi ci si riconnette) oppure se serve una nuova connessione if self.master.is_connected or self.master.connect(password): print("Connected to master") else: print("Error while connecting to master") return False print("Connecting to slave") self.slave = self.master.getSlave(target_name) if self.slave and (not self.slave.is_connected) and self.slave.connect(): print("Connected to slave") else: print("Error while connecting to the slave target") return self.slave
def __init__(self, *args, **kwargs): ''' Not perfect but the bike uses hardcoded constants Warning! Lots of opaque physics and math ''' super(Bike, self).__init__(*args, **kwargs) # Not ideal to use white as the color key # Not ideal to hardcode the bike image asset self.original, self.rect = util.load_image('bike.png', (255,255,255)) self.image = self.original self.speed = 0 self.max_speed = 5 # Is this bike moving? self.driving = 0 # Each bike has its own target self.target = Target() # start at the origin self.x, self.y = self.rect.centerx, self.rect.centery self.angle = 0.0 self.dt = 0.0 # Some physics constants. These and the image ought to be parameters # F_c = mv*v/r --> v_max = sqrt(F_traction/m) * sqrt(r) self.ft = 5.0 self.mass = 200.0 self.brake = 0.1 self.accel = 0.05 self.draw_cb = []
def __init__(self, name, type, srcs, deps, kwargs): """Init the go target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, type, srcs, deps, None, blade.blade, kwargs) self._set_go_package() self._init_go_environment()
def __init__(self, name, type, srcs, deps, prebuilt, blade, kwargs): """Init method. Init the java jar target. """ srcs = var_to_list(srcs) deps = var_to_list(deps) Target.__init__(self, name, type, srcs, deps, blade, kwargs)
def check_depends(self, builder): if Target.check_depends(self, builder): return True if not os.path.exists(self.filename): return True last_mod = os.path.getctime(self.filename) for dep in self.depends: if dep.startswith('@'):continue files = glob.glob(os.path.expanduser(dep)) if not len(files): raise Exception, 'file not found %s -- depended on by ' % dep + self.filename for fname in files: if last_mod < os.path.getctime(fname): return True return False
def openBackup(self): # WARNING -> obsolete, use targets and performance result = Result() tarTemp = Target(0) with open("backup.txt") as f: temp = f.readlines() f.close() # open("backup.txt", "w").close() # TODO uncomment to activate backup refresh for index, line in enumerate(temp): # on parcourt toutes les lignes du fichier if line.__len__() > 10 and line[:1] == "|": # la ligne ne contient pas qu'un | if index < temp.__len__() - 1 and temp[index + 1][:13] != line[:13]: # on est pas sur une ligne partielle line = line.split(",") tarTemp = Target(line[0][1:]) lineb = line[1].split("/") print(lineb.__len__()) for p in lineb: tempPoint = Point(line[0][1:], p) tarTemp.addPoint(tempPoint) del tempPoint result.append(tarTemp) return result # def targets(self): # result = Result() # return 0
def start(self): #Call to Analyze APK #Creating directory for the current apk apkname = os.path.basename(os.path.splitext(self.apkpath)[0]) dir = self.config.outputdir + str(apkname) + "/" #Creating directory if not exists if not os.path.exists(dir): #print "Creating directory " + str(dir) + " for APK " + str(apkname) + "..." os.makedirs(dir) os.chmod(dir,0755) static_target = str(self.apkpath) #this must be the complete path of apk file logpath = self.config.outputdir + apkname + '/log.txt' log = Logger(logpath) #Opening APK with Androguard targetapp = Target(static_target,self.config) if targetapp.status: #If open APK result is OK, we continue... if targetapp.package_name is not None: session_name = targetapp.package_name #usare md5, meglio else: session_name = "dummyname" #Check if the current APK has a cache file if os.path.isfile(dir + "cache"): log.write("Restoring session for " + apkname) targetapp.restore_session(dir + "cache") else: log.write("Saving session for " + apkname) targetapp.save_session(dir + "cache") # Creating database connection database = hashesDB(self.config.dbpath) database.connect() manifestInfo = Manifest(targetapp) #Changing stdout to apkName.txt file (Normal output and errors) manifestAnalysis = ManifestAnalyzer(manifestInfo,targetapp); log.write("analyzing...\n" + targetapp._print()) #manifestInfo.checkPermissions(self.config,apkname,targetapp.package_name,log) <- JSON manifestInfo.checkPermissionsInDB(self.config, apkname, database) # <- DB log.write(apkname + " has been analyzed.") print apkname + " has been analyzed." print "**********************************************************" #Check frida option if self.launch_writer: frida = Frida(self.apkpath) log.close() database.close() else: shutil.rmtree(dir) #Deleting folder for apk analysis
class Coffesploit(object): """Main Class""" def __init__(self, basepath): self.target = Target() self.tool = None self.pluginmanager = PluginManager() self.helper = Help() self.basepath = basepath def set_target(self,rhost=None,url=None): if url is not None: self.target.seturl(url) if rhost is not None: self.target.setrhost(rhost) def set(self, arg1, arg2): self.pluginmanager.current_plugin.set_arg(arg1,arg2) def show(self,arg): if arg == "target": print "ip:",self.target.getrhost(),"url:",self.target.geturl() if arg == "status": if self.pluginmanager.current_plugin is not None: self.pluginmanager.plugin_status() if arg == "version": print "Currnt Version:",self.version() def use(self,arg): self.pluginmanager.load_plugin(arg) def run(self): self.pluginmanager.plugin_run() self.pluginmanager.plugin_result() def main_help (self): return self.helper.main_help() def main_list (self): return self.pluginmanager.importer.get_plugins_list() def help(self,arg): """show help info of t""" if arg == "target": self.helper.help_set_tartget() if arg == "show": self.helper.help_show() if arg == "use": self.helper.help_use() def exit(self): exit(0) def version(self): return __Version__
def mouseReleaseEvent(self, QMouseEvent): x = QMouseEvent.x() y = QMouseEvent.y() if self.mouseActionType == Map.PlaceRobotAction: self.mouseActionType = Map.NoAction self.simStats.btPlaceRobot.setEnabled(False) ab = x - self.robot.posX mb = math.sqrt(math.pow(x - self.robot.posX, 2) + math.pow(y - self.robot.posY, 2)) if mb == 0: newTheta = 0 else: newTheta = math.acos(ab / mb) if y < self.robot.posY: newTheta = math.pi - newTheta + math.pi self.robot.setOrientation(newTheta) if self.target is not None: # I am computing the angle relative to Ox ax. x = self.target.x - self.robot.posX y = self.target.y - self.robot.posY ab = x mb = math.sqrt(x * x + y * y) if mb == 0: theta = 0 else: theta = math.acos(ab / mb) if self.target.y < self.robot.posY: theta = math.pi - theta + math.pi theta = theta - newTheta if theta < 0: theta = theta + 2 * math.pi self.robot.setTargetDirection(theta) self.repaint() elif self.mouseActionType == Map.PlaceTargetAction: self.target = Target(x, y) self.mouseActionType = Map.NoAction self.simStats.btPlaceTarget.setEnabled(False) self.simStats.btPlaceRobot.setEnabled(True) self.repaint() elif self.mouseActionType == Map.PlaceBlockAction: self.dragXend = x self.dragYend = y self.dragObject.updateDrag(self.dragXstart, self.dragYstart, self.dragXend, self.dragYend) self.objects.append(self.dragObject) self.dragObject = None self.saveToImage = True self.setChanged(True) self.mouseActionType = Map.NoAction #TODO #print(QMouseEvent.pos()) self.repaint()