def consistencygroup_list(args): obj = ConsistencyGroup(args.ip, args.port) try: uris = obj.list(args.project, args.tenant) output = [] rawoutput = [] for uri in uris: cg = obj.show(uri, args.project, args.tenant) if(cg): rawoutput.append(cg) from volume import Volume from storagesystem import StorageSystem cg["system_consistency_groups"] = " " if("volumes" in cg): volumeuris = common.get_node_value(cg, "volumes") volobj = Volume(args.ip, args.port) volumenames = [] for volume in volumeuris: vol = volobj.show_by_uri(volume['id']) if(vol): volumenames.append(vol['name']) cg['volumes'] = volumenames volumenames = [] output.append(cg) if(not args.verbose): if(len(output)): TableGenerator(output, ['name', 'volumes']).printTable() else: if(len(rawoutput)): return common.format_json_object(rawoutput) except SOSError as e: raise SOSError(SOSError.SOS_FAILURE_ERR, "Consistency Group List failed:\n" + e.err_text)
def __init__(self, oled, hyp): logger.info("Initializing hardware") import RPi.GPIO as GPIO import smbus self.bus = smbus.SMBus(1) # Rev 2 Pi self.outPa = 18 #Relais für PA2200 self.outTv = 16 #Relais für TV und Sony-Verstärker self.outPhono = 33 #Relais für Phono-Preamp Power self.Out_pwr_rel = 29 #Relais für Ampi-Ringkerntrafo self.inMcpInt = 37 self.inVolDir = 36 self.inVolClk = 7 self.inVolMute = 15 self.validSources = [ 'Aus', 'CD', 'Schneitzlberger', 'Portable', 'Hilfssherriff', 'Bladdnspiela', 'Himbeer314' ] self.source = "Aus" self.ampPwr = False self.tvPwr = False self.oled = oled #OLED-Objekt erzeugen self.hyp = hyp #Hyperion-Objekt erzeugen self.kodi = Kodi("http://localhost/jsonrpc") self.initGpios() #GPIOs initialisieren self.volume = Volume(self.oled, self.bus) #Volumen-Objekt erzeugen self.sources = Sources(self.oled, self.bus) #Quellen-Objekt erzeugen
def _get_resource_lun_tuple(self, resources, resType, baseResUri, tenantname, projectname, blockTypeName): copyEntries = [] snapshotObject = Snapshot(self.__ipAddr, self.__port) volumeObject = Volume(self.__ipAddr, self.__port) for copy in resources: copyParam = [] try: copyParam = copy.split(":") except Exception as e: raise SOSError( SOSError.CMD_LINE_ERR, "Please provide valid format volume: lun for parameter " + resType ) copy = dict() if not len(copyParam): raise SOSError(SOSError.CMD_LINE_ERR, "Please provide atleast volume for parameter " + resType) if resType == "volumes": fullvolname = tenantname + "/" + projectname + "/" fullvolname += copyParam[0] copy["id"] = volumeObject.volume_query(fullvolname) if resType == "snapshots": copy["id"] = snapshotObject.snapshot_query("block", blockTypeName, baseResUri, copyParam[0]) if len(copyParam) > 1: copy["lun"] = copyParam[1] copyEntries.append(copy) return copyEntries """
def test_get_edge_neighbors_with_history(): """test the get neighbor function""" volume = Volume(data=np.random.random((3, 3, 3))) sponsor_history = [(0, 0, 1)] neighbors = volume._get_neighbors((0, 0, 2), sponsor_history) actual_neighbors = [(0, 1, 2), (1, 0, 2)] npt.assert_array_equal(neighbors.sort(), actual_neighbors.sort())
def consistencygroup_list(args): obj = ConsistencyGroup(args.ip, args.port) try: uris = obj.list(args.project, args.tenant) output = [] rawoutput = [] for uri in uris: cg = obj.show(uri, args.project, args.tenant) if (cg): rawoutput.append(cg) from volume import Volume from storagesystem import StorageSystem cg["system_consistency_groups"] = " " if ("volumes" in cg): volumeuris = common.get_node_value(cg, "volumes") volobj = Volume(args.ip, args.port) volumenames = [] for volume in volumeuris: vol = volobj.show_by_uri(volume['id']) if (vol): volumenames.append(vol['name']) cg['volumes'] = volumenames volumenames = [] output.append(cg) if (not args.verbose): if (len(output)): TableGenerator(output, ['name', 'volumes']).printTable() else: if (len(rawoutput)): return common.format_json_object(rawoutput) except SOSError as e: raise SOSError(SOSError.SOS_FAILURE_ERR, "Consistency Group List failed:\n" + e.err_text)
def __init__(self, master): # create GUI self.gpio = pigpio.pi() self.master = master self.master.title('JoyStick Test') label = tk.Label(root, text='Joystick') label.pack() self.gui = GuiRarm(master=root) self.gui.createCordinateLabelServo() self.gui.createButton(btn_name='Finish', callback=self.cleanup) #self.gui.createCircleJs2(200,200,220,220,'blue') #JoyStick instanse self.jsR = JoyStick(-1, 4, 27) self.val_horz = 0 #self.jsL = JoyStick(7,4,22) self.jsL = JoyStick(2, -1, 22) self.val_vert = 0 #Volume instance self.vol = Volume(6) self.val_vol = 0 self.vol_sum = 0 self.sampleCount = 0 #ServMotor #self.servo= ServMotor(18,180,0) self.servo = I2cServo() #PWM Freq: 60Hz self.servo.setPWMFreq(60) # Led instance self.Led = Led(4) self.Led.setLedOn() # PowrSw self.PowSw = Sw(17, pud='pudup') self.PowSwCont = 0
def consistencygroup_list(args): obj = ConsistencyGroup(args.ip, args.port) try: uris = obj.list(args.project, args.tenant) output = [] for uri in uris: cg = obj.show(uri, args.project, args.tenant) if(cg): from volume import Volume from storagesystem import StorageSystem if( "volumes" in cg): volumeuris = common.get_node_value(cg, "volumes") volobj = Volume(args.ip, args.port) volumenames = [] for volume in volumeuris: vol = volobj.show_by_uri(volume['id']) if(vol): volumenames.append(vol['name']) cg['volumes'] = volumenames ssobj = StorageSystem(args.ip, args.port) if( "storage_controller" in cg): ssrow = common.get_node_value(cg, "storage_controller") storagesystem = ssobj.show_by_uri(ssrow['id']) cg['storage_controller'] = storagesystem['name'] output.append(cg) if(len(output)): TableGenerator(output, ['name', 'volumes', 'storage_controller']).printTable() except SOSError as e: raise SOSError(SOSError.SOS_FAILURE_ERR, "Consistency Group List failed:\n" + e.err_text)
def demand_volume(self): """Generates lines for demand volume constraints""" for sn in range(1, self.n_source_nodes+1): for dn in range(1, self.n_destination_nodes+1): volume = Volume(self.n_transit_nodes) volume.create_constraint(sn, dn) self.add_line(volume)
def generate(self): self.states = [] # Generate all quantities for each state. states_q = itertools.product(Inflow.get_quantities(), Volume.get_quantities(), Outflow.get_quantities()) # Create objects for each state. for state_q in states_q: self.states.append( State(Inflow(state_q[0], None), Volume(state_q[1], None), Outflow(state_q[2], None))) print "[trace] - Generate states - remove constraints" self.remove_inconsistencies() print "[trace] - Generate states - Calculate derivitives" self.calc_derives() print "[trace] - Generate states - Unpack the inflow derivitives" self.unpack_inflow() print "[trace] - Generate states - Set state ids" # At this point all valid states are created and should receive an id for i, state in enumerate(self.states): state.set_id(i) print "[trace] - Create paths - Start" self.create_paths() print "[trace] - Create paths - End" return self.states, self.paths
def update(self, name, project, tenant, add_volumes, remove_volumes, sync, synctimeout=0): ''' This function is used to add or remove volumes from consistency group It will update the consistency group with given volumes. parameters: name : Name of the consistency group. project: Name of the project path. tenant: Container tenant name. add_volumes : volumes to be added to the consistency group remove_volumes: volumes to be removed from CG. return returns with status of creation. ''' if (tenant is None): tenant = "" fullproj = tenant + "/" + project projobj = Project(self.__ipAddr, self.__port) projuri = projobj.project_query(fullproj) parms = [] add_voluris = [] remove_voluris = [] #volumes = None from volume import Volume volobj = Volume(self.__ipAddr, self.__port) if (add_volumes): for volname in add_volumes: fullvolname = tenant + "/" + project + "/" + volname add_voluris.append(volobj.volume_query(fullvolname)) volumes = {'volume': add_voluris} parms = {'add_volumes': volumes} if (remove_volumes): for volname in remove_volumes: fullvolname = tenant + "/" + project + "/" + volname remove_voluris.append(volobj.volume_query(fullvolname)) volumes = {'volume': remove_voluris} parms = {'remove_volumes': volumes} body = json.dumps(parms) uri = self.consistencygroup_query(name, project, tenant) (s, h) = common.service_json_request( self.__ipAddr, self.__port, "PUT", self.URI_CONSISTENCY_GROUPS_INSTANCE.format(uri), body, None, None) o = common.json_decode(s) if (sync): return self.check_for_sync(o, sync, synctimeout) else: return o
def generate(self): self.states = [] print "\n[trace] - Generate states - Generate quantity combinations:" # Generate all quantities for each state. states_q = itertools.product(Inflow.get_quantities(), Volume.get_quantities(), Outflow.get_quantities(), Height.get_quantities(), Pressure.get_quantities()) # Create objects for each state. for state_q in states_q: self.states.append( BonusState(Inflow(state_q[0], None), Volume(state_q[1], None), Outflow(state_q[2], None), Height(state_q[3], None), Pressure(state_q[4], None))) pprint.pprint(self.states) print "[trace] - Generate states - " +\ str(len(self.states)) + " current states" print "\n[trace] - Generate states - remove constraints:" self.remove_inconsistencies() pprint.pprint(self.states) print "[trace] - Generate states - " +\ str(len(self.states)) + " current states" print "\n[trace] - Generate states - Calculate derivitives:" self.calc_derives() pprint.pprint(self.states) print "[trace] - Generate states - " +\ str(len(self.states)) + " current states" print "\n[trace] - Generate states - Unpack the inflow derivitives" self.unpack_inflow() print "\n[trace] - Generate states - Set state ids" # At this point all valid states are created and should receive an id for i, state in enumerate(self.states): state.set_id(i) pprint.pprint(self.states) print "[trace] - Generate states - " +\ str(len(self.states)) + " current states" print "\n[trace] - Create paths - Start" self.create_paths() pprint.pprint(self.paths) print "[trace] - Generate states - " +\ str(len(self.paths)) + " current paths" print "[trace] - Create paths - End\n" return self.states, self.paths
def update(self, name, project, tenant, add_volumes, remove_volumes, sync,synctimeout=0): ''' This function is used to add or remove volumes from consistency group It will update the consistency group with given volumes. parameters: name : Name of the consistency group. project: Name of the project path. tenant: Container tenant name. add_volumes : volumes to be added to the consistency group remove_volumes: volumes to be removed from CG. return returns with status of creation. ''' if(tenant is None): tenant = "" fullproj = tenant + "/" + project projobj = Project(self.__ipAddr, self.__port) projuri = projobj.project_query(fullproj) parms = [] add_voluris = [] remove_voluris = [] #volumes = None from volume import Volume volobj = Volume(self.__ipAddr, self.__port) if(add_volumes): for volname in add_volumes: fullvolname = tenant + "/" + project + "/" + volname add_voluris.append(volobj.volume_query(fullvolname)) volumes = {'volume': add_voluris} parms = {'add_volumes': volumes} if(remove_volumes): for volname in remove_volumes: fullvolname = tenant + "/" + project + "/" + volname remove_voluris.append(volobj.volume_query(fullvolname)) volumes = {'volume': remove_voluris} parms = {'remove_volumes': volumes} body = json.dumps(parms) uri = self.consistencygroup_query(name, project, tenant) (s, h) = common.service_json_request( self.__ipAddr, self.__port, "PUT", self.URI_CONSISTENCY_GROUPS_INSTANCE.format(uri), body, None, None) o = common.json_decode(s) if(sync): return self.check_for_sync(o, sync,synctimeout) else: return o
def exportgroup_list(args): obj = ExportGroup(args.ip, args.port) try: uris = obj.exportgroup_list(args.project, args.tenant) output = [] if len(uris) > 0: for uri in uris: eg = obj.exportgroup_show(uri, args.project, args.tenant) # The following code is to get volume/snapshot name part of # export group list. if eg: if "project" in eg and "name" in eg["project"]: del eg["project"]["name"] volumeuris = common.get_node_value(eg, "volumes") volobj = Volume(args.ip, args.port) snapobj = Snapshot(args.ip, args.port) volnames = [] strvol = "" for volumeuri in volumeuris: strvol = str(volumeuri["id"]) if strvol.find("urn:storageos:Volume") >= 0: vol = volobj.show_by_uri(strvol) if vol: volnames.append(vol["name"]) elif strvol.find("urn:storageos:BlockSnapshot") >= 0: snapshot = snapobj.snapshot_show_uri("block", None, strvol) if snapshot: volnames.append(snapshot["name"]) eg["volumes_snapshots"] = volnames output.append(eg) if args.verbose: return common.format_json_object(output) if len(output) > 0: if args.long: from common import TableGenerator TableGenerator( output, ["module/name", "volumes_snapshots", "initiator_node", "initiator_port", "tags"] ).printTable() else: from common import TableGenerator TableGenerator(output, ["module/name"]).printTable() except SOSError as e: raise common.format_err_msg_and_raise("list", "exportgroup", e.err_text, e.err_code)
def run(self, *args, **kwargs): while True: df = LoadNet().get_QVIX() self.update_qvix.emit(df) df_north = LoadNet().get_north() self.update_north.emit(df_north) df_vol, cha = Volume().update() data, last = LoadNet().get_50_163() ser = (data['current'] - last) / last self.update_vol.emit(df_vol, ser) if not self.data_model.df_op.empty: df_month = self.data_model.iv_month_50300() self.update_month.emit(df_month) df_iv50, df_iv300 = self.data_model.get_iv() self.update_iv.emit(df_iv50, df_iv300) hp = HoldPositions() greek = hp.update(self.data_model.df_op) self.update_greek.emit(greek) time.sleep(3)
def should_have_printed_usage_instructions(monkeypatch) -> None: print_coloured_calls = [] mock_parse_argv(MODULE_NAME, 'Volume', monkeypatch) monkeypatch.setattr(f"{MODULE_NAME}.print_coloured", lambda *a, **k: print_coloured_calls.append('')) Volume().usage() assert len(print_coloured_calls) == 2
def main(): ren = Rendering((200, 300), (1, 0, 0)) mat_sphere = SurfaceMaterial('orange_wall', (1, 0.7, 0.0), 0.8, (1, 1, 1), 0, 50, 1.0) asphere = Surface.from_sphere(( 0, 0, 0, ), 1, (1, 31), mat_sphere) mat_mobius = SurfaceMaterial('pink_metallic', (1, 0.8, 1), 0.1, (1, 1, 1), 0.9, 50, 1.0) amobius = Surface.from_mobius(mat_mobius) liver = Surface.from_STL_file('liver.stl') mat_head = VolumeMaterial('head', [(0, (0, 0, 0)), (1000, (1, 1, 1))], [(0, 0), (500, 0), (4000, 1)]) head = Volume.from_VTK_file('head.vtk', mat_head) ren.renderer.AddVolume(head) ren.renderer.AddActor(liver) ren.renderer.AddActor(asphere) ren.renderer.AddActor(amobius) ren.interactor.Initialize() ren.interactor.Start()
class AdcDevTest(): def __init__(self): self.volt_vol = 0 self.volt_ls = 0 self.vol = Volume(0) # self.ls = LightSens() def VoltageTest(self): self.volt_vol = self.vol.getValVol() # self.volt_ls = self.ls.getVolt() print('Volume(V)= %d' % self.volt_vol) # 'LightSens(V)= %2.2f' % self.volt_ls time.sleep(0.5) def cleanup(self): self.vol.cleanup()
def exportgroup_remove_volumes( self, sync, exportgroupname, tenantname, projectname, volumenames, snapshots=None, cg=None ): exportgroup_uri = self.exportgroup_query(exportgroupname, projectname, tenantname) volumeIdList = [] # get volume uri if tenantname is None: tenantname = "" volumeObject = Volume(self.__ipAddr, self.__port) for vol in volumenames: fullvolname = tenantname + "/" + projectname + "/" + vol volumeIdList.append(volumeObject.volume_query(fullvolname)) return self.exportgroup_remove_volumes_by_uri( exportgroup_uri, volumeIdList, sync, tenantname, projectname, snapshots, cg )
def deform_volume(): data = np.random.random((9, 9, 9, 3)) # random RGB colors volume = Volume(data=data, deformation_range=(0.6, 0.6, 0.6), spacing=(0.2, 0.2, 0.2)) deformation = np.asarray([1, 1, 3]) deformation_index = (7, 7, 8) volume.deform(deformation_index, deformation) volume.show() volume.show(scatter=False)
def generate_slab_phantom(size, voxelsize, iso, slab_defs, phantom_name='slab'): """Args: slab_defs ([(int, material), ...]: define thickness and material of each slice in slab phantom """ os.makedirs(OUTPUT_DIR, exist_ok=True) dens = np.empty(np.product(size)) # write Monte Carlo geo.txt file center = list(iso) center[2] += (voxelsize[2] * size[2] / 2.) print("Generatring %s slab phantom:" % phantom_name) print(" Isocenter is at %s" % str(center)) print(" Phantom size in voxel is %s" % str(size)) with open( os.path.join(OUTPUT_DIR, "mcgeo_{!s}.txt").format(phantom_name), 'w') as fd: fd.write("{:d} {:d} {:d}\n".format(*size)) fd.write("{:f} {:f} {:f}\n".format(*voxelsize)) fd.write("{:f} {:f} {:f}\n".format(*center)) # ZYX ORDERING idx = 0 for layer in slab_defs: for ii in range(np.prod([layer[0], *size[:2]])): dens[idx] = layer[1][0] fd.write("{:f} {:d} {:d} {:f}\n".format(*layer[1])) idx += 1 # write dosecalc ready phantom file and fmaps file # vol = Volume.CenterAt(dens.astype('f').reshape(size[::-1]), np.divide(center, 10), np.divide(voxelsize, 10)) dens = dens.reshape(size[::-1]) dens = np.concatenate([np.zeros((4, size[1], size[0])), dens], axis=0) vol = Volume.CenterAt( np.ascontiguousarray(np.transpose(dens.astype('f'), (1, 0, 2))), (0, voxelsize[1] * (dens.shape[1] - 4) / 20, 0), np.divide(voxelsize, 10)) print(" Data written to file is of size %s" % str(vol.data.shape)) vol.generate( os.path.join(OUTPUT_DIR, 'phantom_{!s}.h5'.format(phantom_name))) fmaps = Fmaps() fmap_wts = np.ones((10, 10)) # fmaps.addBeam(Beam(fmap_wts, gantry_deg=-90, couch_deg=90, coll_deg=0, iso=np.divide(iso, 10), sad=100, beamlet_size=(0.5, 0.5))) fmaps.addBeam( Beam(fmap_wts, gantry_deg=0, couch_deg=0, coll_deg=0, iso=np.divide(iso, 10), sad=100, beamlet_size=(0.5, 0.5))) fmaps.generate( os.path.join(OUTPUT_DIR, 'fmaps_{!s}.h5'.format(phantom_name)))
def exportgroup_list(args): obj = ExportGroup(args.ip, args.port) try: uris = obj.exportgroup_list(args.project, args.tenant) output = [] if(len(uris) > 0): for uri in uris: eg = obj.exportgroup_show(uri, args.project, args.tenant) # The following code is to get volume/snapshot name part of export group list. if(eg): if("project" in eg and "name" in eg["project"]): del eg["project"]["name"] volumeuris = common.get_node_value(eg, "volumes") volobj = Volume(args.ip, args.port) snapobj = Snapshot(args.ip, args.port) volnames = [] strvol = "" for volumeuri in volumeuris: strvol = str(volumeuri['id']) if(strvol.find('urn:storageos:Volume') >= 0): vol = volobj.show_by_uri(strvol) if(vol): volnames.append(vol['name']) elif(strvol.find('urn:storageos:BlockSnapshot')>= 0): snapshot = snapobj.snapshot_show_uri('block', None, strvol) if(snapshot): volnames.append(snapshot['name']) eg['volumes_snapshots']=volnames output.append(eg) if(args.verbose == True): return common.format_json_object(output) if(len(output) > 0): if(args.long == True): from common import TableGenerator TableGenerator(output, ['name', 'volumes_snapshots','initiator_node', 'initiator_port']).printTable() else: from common import TableGenerator TableGenerator(output, ['name']).printTable() except SOSError as e: raise common.format_err_msg_and_raise("list", "exportgroup", e.err_text, e.err_code)
def execute(self) -> str: log('Good night!') automations = [ Volume(['0.0']), Bluetooth(['off']), Wifi(['off']), Sleep(), ] for automation in automations: automation.execute() return ''
def should_not_have_parsed_argv_with_wrong_or_no_option( monkeypatch, argv: List[str]) -> None: def mock_raise_error(*args: tuple, **kwargs: dict) -> None: assert kwargs['usage'] is not None raise SystemExit(0) # Controlled early exit monkeypatch.setattr(f"{MODULE_NAME}.raise_error", mock_raise_error) with pytest.raises(SystemExit) as e: Volume(argv) assert e.type == SystemExit assert e.value.code == 0
def should_have_executed(monkeypatch) -> None: def mock_build_apple_script(*args: tuple, **kwargs: dict) -> str: assert args[1] == volume_level return apple_script def mock_execute_cmd(*args: tuple, **kwargs: dict) -> str: assert args[0] == ['osascript', '-e', apple_script] return f" {expected_result} " apple_script = next_alphanumeric(16) mock_parse_argv(MODULE_NAME, 'Volume', monkeypatch) mute_logs(MODULE_NAME, monkeypatch) monkeypatch.setattr(f"{MODULE_NAME}.Volume.build_apple_script", mock_build_apple_script) monkeypatch.setattr(f"{MODULE_NAME}.execute_cmd", mock_execute_cmd) volume_level = random.random() expected_result = next_alphanumeric(10) automation = Volume() automation.volume = volume_level automation.execute()
def convert_unit(self, value, input_unit, output_unit): if self.measurement is 'length': return Length(value, input_unit, output_unit).convert() if self.measurement is 'temperature': return Temperature(value, input_unit, output_unit).convert() if self.measurement is 'area': return Area(value, input_unit, output_unit).convert() if self.measurement is 'volume': return Volume(value, input_unit, output_unit).convert() if self.measurement is 'weight': return Weight(value, input_unit, output_unit).convert() return "Not a valid measurement is entered! Select from : length, temperature, volume, area, weight"
def create_root_volume(self, defaults): """ Create a root volume for the vFiler if one hasn't been manually defined """ log.debug("No manually defined root volume. Creating one...") ns = self.populate_namespace() try: volname = defaults.get('vfiler', 'root_volume_name') % ns except (NoSectionError, NoOptionError): volname = '%s_root' % self.name pass # FIXME: This can probably be improved somehow usable = float(defaults.get('vfiler', 'root_volume_usable')) aggr = self.get_root_aggregate() log.debug("got root aggr") xmldata = """<volume type="root" name="%s" usable="%s" raw="%s" /> """ % (volname, usable, usable) node = etree.fromstring(xmldata) vol = Volume() vol.configure_from_node(node, defaults, aggr) vol.snapreserve = int(defaults.get('vfiler', 'root_volume_snapreserve')) vol.space_guarantee = 'volume' if defaults.getboolean('vfiler', 'backup_root_volume'): log.warn("Request to back up vfiler root volume") log.debug("Root volume: %s", vol) # Add the volume as a child of the root aggregate aggr.add_child(vol) pass
def get_attached_volumes(self, instanceId, latest=False): instance = self.id2inst.get(instanceId, None) if instance == None: raise Exception if latest: self.id2vols.clear() volumes = self.handle.volumes.get_server_volumes(instanceId) vols = [] for volume in volumes: vols.append(Volume(instance, volume)) self.id2vols[instanceId] = vols return self.id2vols[instanceId]
def create_root_volume(self, defaults): """ Create a root volume for the vFiler if one hasn't been manually defined """ log.debug("No manually defined root volume. Creating one...") ns = self.populate_namespace() try: volname = defaults.get("vfiler", "root_volume_name") % ns except (NoSectionError, NoOptionError): volname = "%s_root" % self.name pass # FIXME: This can probably be improved somehow usable = float(defaults.get("vfiler", "root_volume_usable")) aggr = self.get_root_aggregate() log.debug("got root aggr") xmldata = """<volume type="root" name="%s" usable="%s" raw="%s" /> """ % ( volname, usable, usable, ) node = etree.fromstring(xmldata) vol = Volume() vol.configure_from_node(node, defaults, aggr) vol.snapreserve = int(defaults.get("vfiler", "root_volume_snapreserve")) vol.space_guarantee = "volume" if defaults.getboolean("vfiler", "backup_root_volume"): log.warn("Request to back up vfiler root volume") log.debug("Root volume: %s", vol) # Add the volume as a child of the root aggregate aggr.add_child(vol) pass
def update(args): if(args.newname is None and args.description is None and args.add_volumes is None and args.remove_volumes is None and args.parent is None): raise SOSError(SOSError.CMD_LINE_ERR, "viprcli volume group update: error: at least one of " + "the arguments -np/-newname -d/-description -a/-add_volumes " + " -r/-remove_volumes is required") add_vols = [] if(args.add_volumes and len(args.add_volumes) > 0): for item in args.add_volumes.split(','): if (common.is_uri(item)): add_vols.append(item) else: vol = Volume(args.ip, args.port) volid = vol.show(item, False, False)['id'] add_vols.append(volid) rem_vols = [] if(args.remove_volumes and len(args.remove_volumes) > 0): for item in args.remove_volumes.split(','): if (common.is_uri(item)): rem_vols.append(item) else: vol = Volume(args.ip, args.port) try: volid = vol.show(item, False, False)['id'] rem_vols.append(volid) except: continue obj = VolumeGroup(args.ip, args.port) try: obj.update(args.name, args.newname, args.description, ",".join(add_vols), args.consistency_group, args.replication_group, ",".join(rem_vols), args.parent) except SOSError as e: raise e
def read_volume(self): options = QFileDialog.Options() filename, ok = QFileDialog.getOpenFileName(self, "Read volume file", "", "", options=options) if ok: volume = Volume.read_file(filename, self.scene.material('volume_default')) if volume != None: self.add_volume(volume) else: reply = QMessageBox.warning(self, 'Error', "Something went wrong")
def split_on_volume(): ''' split text into volume objects ''' with open( 'files/pdfminer/output/ferguson_grand_jury_testimony.txt') as file: volumes = [] recording = False text = file.readlines() for line in text: line_details = get_line_details(line) # split on volumes, where VOLUME [IVX]+ is the only text match = re.match("(VOLUME [IVX]+)", line_details["text"]) if match: volume = Volume() volume.debateSection(match.group(1)) volumes.append(volume) recording = True # get the rest of the text too if recording: volume.full_text.append(line_details) return volumes
def __init__(self): self.UPDATE_TIME =10000 self.model = DataModel() self.v = Volume() self.hold_positions = HoldPositions() self.colors = ['r','orange','darkgreen','k'] #plt.ion() self.fig = plt.figure(facecolor='darkgray',figsize=(19,10)) plt.tight_layout(pad=1, w_pad=1.0, h_pad=1.0) self.ax_iv50 = self.fig.add_subplot(231) self.ax_iv300 = self.fig.add_subplot(232) self.ax_iv_month = self.fig.add_subplot(233) self.ax_volume =self.fig.add_subplot(236) self.ax_greek =self.fig.add_subplot(235) self.ax_QVIX =self.fig.add_subplot(234) # t= threading.Thread(target=self.loop) # t.start() timer = self.fig.canvas.new_timer(interval=self.UPDATE_TIME) timer.add_callback(self.loop) timer.start() plt.show()
def init_vipr_cli_components(self): import common as vipr_utils vipr_utils.COOKIE = None from exportgroup import ExportGroup from host import Host from hostinitiators import HostInitiator from snapshot import Snapshot from virtualarray import VirtualArray from volume import Volume # instantiate a few vipr cli objects for later use self.volume_obj = Volume(self.configuration.vipr_hostname, self.configuration.vipr_port) self.exportgroup_obj = ExportGroup(self.configuration.vipr_hostname, self.configuration.vipr_port) self.host_obj = Host(self.configuration.vipr_hostname, self.configuration.vipr_port) self.hostinitiator_obj = HostInitiator( self.configuration.vipr_hostname, self.configuration.vipr_port) self.varray_obj = VirtualArray(self.configuration.vipr_hostname, self.configuration.vipr_port) self.snapshot_obj = Snapshot(self.configuration.vipr_hostname, self.configuration.vipr_port)
def __init__(self, volume, template, gpu): self.gpu = gpu volume_gpu = gu.to_gpu(volume) self.fwd_plan = Plan(volume.shape, volume.dtype, np.complex64) self.volume_fft = gu.zeros_like(volume_gpu, dtype=np.complex64) fft(volume_gpu, self.volume_fft, self.fwd_plan) self.template_fft = gu.zeros_like(volume_gpu, dtype=np.complex64) self.ccc_map = gu.zeros_like(volume_gpu, dtype=np.float32) self.norm_volume = gu.prod(volume_gpu.shape) #self.scores = gu.zeros_like(volume_gpu, dtype=np.float32) #self.angles = gu.zeros_like(volume_gpu, dtype=np.float32) self.padded_volume = gu.zeros_like(volume_gpu, dtype=np.float32) del volume_gpu self.inv_plan = Plan(volume.shape, np.complex64, volume.dtype) self.template = Volume(template)
def get(self, volume_name_or_id_str): # try to cast to int, in case it's an ID volume_name_or_id = None try: volume_name_or_id = int(volume_name_or_id_str) except: volume_name_or_id = volume_name_or_id_str volume = Volume.Read(volume_name_or_id) if volume is None: response_user_error(self, 404, "No such volume") response_end(self, 200, volume.volume_cert_bin, "application/octet-stream") return
def get(self, volume_name_or_id_str, volume_cert_version_str): volume_id = None volume_name = None volume_cert_version = None try: volume_id = int(volume_name_or_id_str) except: volume_name = volume_name_or_id_str try: volume_cert_version = int(volume_cert_version_str) except: response_end(self, 400, "Invalid Request", "text/plain") return if volume_id is None: # look up volume volume = Volume.Read(volume_name) if volume is None or volume.deleted: response_end(self, 404, "Not found", "text/plain") return volume_id = volume.volume_id volume_cert_bundle = VolumeCertBundle.Get(volume_id) if volume_cert_bundle is None: response_end(self, 404, "Not found", "text/plain") return # verify that it matches cert_bundle = VolumeCertBundle.Load(volume_cert_bundle) if cert_bundle.mtime_sec != volume_cert_version: # send gateway the URL to the latest cert bundle hdr = "%s/CERTBUNDLE/%s/%s" % (MS_URL, volume_name_or_id_str, cert_bundle.mtime_sec) self.response.headers['Location'] = hdr response_end(self, 302, "Location: %s" % hdr, "text/plain") return logging.info("Serve volume %s (%s)" % (volume_id, volume_cert_version)) response_end(self, 200, cert_bundle.SerializeToString(), "application/octet-stream") return
def _build_algorithms(self): """ + Description: build algorithms based on data modules. + Input: - + Output: - """ self.algorithms = {} for algo_id, algo_values in self.algorithms_elements.items(): if algo_values[definitions.algorithm] == definitions.crossing_sma: self.algorithms[algo_id] = CrossingSMA(algo_id, algo_values, self.data_modules, self.assets, self.oracle) elif algo_values[definitions.algorithm] == definitions.volume: self.algorithms[algo_id] = Volume(algo_id, algo_values, self.data_modules, self.assets, self.oracle) elif algo_values[ definitions.algorithm] == definitions.twitter_analysis: self.algorithms[algo_id] = TwitterAnalysis( algo_id, algo_values, self.data_modules, self.assets, self.oracle) elif algo_values[ definitions.algorithm] == definitions.virtual_transfer: self.algorithms[algo_id] = VirtualTransfer( algo_id, algo_values, self.data_modules, self.assets, self.oracle, self.world) elif algo_values[definitions.algorithm] == definitions.statarb: self.algorithms[algo_id] = StatArb(algo_id, algo_values, self.data_modules, self.assets, self.oracle, self.world) else: raise ValueError("Bad algorithm: '" + algo_id + "'.") print("\nAlgorithms:") pprint(self.algorithms)
def __init__(self): print("init bohnify") self.listeners = [] self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.PLAY_TOKEN_LOST, self.on_play_token_lost) self.session.preferred_bitrate(spotify.Bitrate.BITRATE_160k) try: self.audio_driver = bohnifysink.BohnifyAlsaSink(self.session,self) except ImportError: print ('No audio sink found; audio playback unavailable.') self.event_loop = spotify.EventLoop(self.session) self.event_loop.start() self.volumeController = Volume.Instance() self.volumeController.setListener(self) self.status["volume"] = self.volumeController.getVolume()
def __init__(self, name, conf, os_auth_info): BaseClient.__init__(self, name, conf, os_auth_info) self.handle = client.Client( os_auth_info["username"], os_auth_info["password"], os_auth_info["tenant_name"], os_auth_info["auth_url"], insecure=True, service_type="compute") # Maybe the client doesn't prefer ssh route self.ssh_info = conf.get("ssh", None) servers = [] try: servers.extend(self.handle.servers.list()) except NotFound: logging.warn("No servers present for client %s" % name) self.pattern = re.compile("^" + os_auth_info["username"] + "-[0-9]{3}") for inst in servers: if not self.pattern.match(inst.name): continue instance = Instance(inst, self.ssh_info) instanceId = instance.get_id() self.id2inst[instanceId] = instance vols = [] try: vols.extend(self.handle.volumes.get_server_volumes(instanceId)) except NotFound: logging.warn("No volume attached for instance %s(%s)" % (instance.get_name(), instance.get_id())) volumes = self.id2vols[instanceId] = [] for vol in vols: volumes.append(Volume(instance, vol))
def volume_convert(): volume = Volume() while True: title() option = str(input(''' [1] centimetro cúbico a Litro [2] Litros a centimetro cúbico [3] Milimetros cúbicos a Litros [s]alir ''')).lower() if option == '1': volume.cmAL() elif option == '2': volume.LAcm() elif option == '3': volume.mcAL() elif option == 's': break else: print('Ingreso un dato invalido')
def stop(self): Bohnify.Instance().endprogram() Volume.Instance().stop() print("end")
class Game(): def __init__(self): # variables ----------------------------------------------- # load background self.backg = Background(BKG_FOLDER + "stars.png") # set initial score self.score = 0 # load sound and music volume from file # if there's a problem with the file, simply create a new one with default values try: volume = pickle.load( open( "volume.p", "rb" ) ) except: volume = { "sound": 100, "music": 30 } pickle.dump( volume, open( "volume.p", "wb" ) ) # sounds self.laserSnd = pygame.mixer.Sound(SND_FOLDER + "laser.wav") self.explodeSnd = pygame.mixer.Sound(SND_FOLDER + "explosion.wav") self.powerUpSnd = pygame.mixer.Sound(SND_FOLDER + "powerUp.wav") # put everything into a list so it's easier to change the volume # the list elements are the same objects as the initial ones # as python copies by reference and not by value (I would have # preferred to use pointers, to avoid ambiguity, but oh well...) self.sounds = [self.laserSnd,self.explodeSnd,self.powerUpSnd] # set volume for all sound objects for snd in self.sounds: snd.set_volume(volume["sound"]/100.) # set new volume # music self.music = pygame.mixer.music.load(MUS_FOLDER + "reachingForTheSun.mp3") pygame.mixer.music.play(-1) # loop pygame.mixer.music.set_volume(volume["music"]/100.) # creating user ship self.userShip = ShipY001() self.userShip.speed = 10 # group of all sprites self.userSprites = pygame.sprite.Group() self.laserSprites = pygame.sprite.Group() self.aiSprites = pygame.sprite.Group() self.powerUpSprites = pygame.sprite.Group() # add to groups self.userSprites.add(self.userShip) # Creating main menu self.menu = Menu(["Quit","Credits","Volume","Play"],self.backg) # Creating pause menu (could be generated later, but shouldn't impact performance) self.pause = Menu(["Quit","Volume","Restart","Continue"],self.backg) # Creating volume menu (could be generated later, but shouldn't impact performance) self.volume = Volume(self.backg,volume) self.volumeBack = 0 # some stupid flag to tell us whether we came from the main menu # of from the pause menu # Creating credits self.credits = Credits(["Sound: Obtained from Freesound", "Music: 'Reaching for the Sun' by Deshiel and Bacon92", "Graphics: Filipa Silva", "Code: Alexandre Lopes"], self.backg) # gameState # Available states: menu, credits ,game, gameOver self.gameState = "menu" # ----------------------------------------------- def handle(self,event): # some flags (this could be re-done in a better way, but for now it works) wasPressedNow = 0 # this is for some stupid hack, see below # Menu =============================================================== if self.gameState == "menu": if event.type == QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE or event.key == pygame.K_RETURN: if self.menu.press() == 3: # play pressed self.gameState = "game" # begin game elif self.menu.press() == 2: # volume pressed self.gameState = "volume" # show volume menu wasPressedNow = 1 self.volumeBack = 1 elif self.menu.press() == 1: # credits pressed self.gameState = "credits" # show credits wasPressedNow = 1 # stupid hack to prevent event from being # read here and in the credits # probably the best solution would be to change # the way everything is structured # but this proved to be easier elif self.menu.press() == 0: # quit pressed pygame.quit() sys.exit() else: pass # throw exception if event.key == pygame.K_DOWN: self.menu.down() if event.key == pygame.K_UP: self.menu.up() # =================================================================== # Pause=============================================================== if self.gameState == "pause": if event.type == QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE or event.key == pygame.K_RETURN: if self.pause.press() == 3: # continue pressed self.gameState = "game" # change state back to game elif self.pause.press() == 2: # restart pressed self.__init__() # return to initial state self.gameState = "game" # change state back to game elif self.pause.press() == 1: # volume pressed self.gameState = "volume" # show volume menu self.volumeBack = 0 wasPressedNow = 1 elif self.pause.press() == 0: # quit pressed pygame.quit() sys.exit() else: pass # throw exception if event.key == pygame.K_DOWN: self.pause.down() if event.key == pygame.K_UP: self.pause.up() # =================================================================== # Volume ============================================================= if self.gameState == "volume" and wasPressedNow == 0: if event.type == QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE or event.key == pygame.K_RETURN: if self.volume.press() == 0: # back pressed if self.volumeBack == 1: # then we should go back to menu self.gameState = "menu" elif self.volumeBack == 0: # then we should go back to the pause menu self.gameState = "pause" else: pass # throw exception # move "cursor" down if event.key == pygame.K_DOWN: self.volume.down() # move "cursor" up if event.key == pygame.K_UP: self.volume.up() # raise music volume if it is selected if event.key == pygame.K_RIGHT and self.volume.press() == 2: pygame.mixer.music.set_volume(self.volume.right()) # update volume # newVolume = pygame.mixer.music.get_volume() + .1 # get current volume and increment # if newVolume > 1.: # if it exceeds the maximum # newVolume = 1. # pygame.mixer.music.set_volume(newVolume) # #save new volume to file # pickle.dump( {"sound": self.sounds[0].get_volume(), # "music": pygame.mixer.music.get_volume()}, # open( "volume.p", "wb" ) ) # lower music volume if it is selected if event.key == pygame.K_LEFT and self.volume.press() == 2: pygame.mixer.music.set_volume(self.volume.left()) # update volume # if newVolume < 0.: # if it exceeds the maximum # newVolume = 0. # pygame.mixer.music.set_volume(newVolume) # # save new volume to file # pickle.dump( {"sound": self.sounds[0].get_volume(), # "music": pygame.mixer.music.get_volume()}, # open( "volume.p", "wb" ) ) # raise volume if it is selected if event.key == pygame.K_RIGHT and self.volume.press() == 1: newVolume = self.volume.right() for snd in self.sounds: snd.set_volume(newVolume) # set new volume # newVolume = self.sounds[0].get_volume() + .1 # get current volume and increment # if newVolume > 1.: # if it exceeds the maximum # newVolume = 1. # # set now for every sound object we have # # save new volume to file # pickle.dump( {"sound": self.sounds[0].get_volume(), # "music": pygame.mixer.music.get_volume()}, # open( "volume.p", "wb" ) ) # lower volume if it is selected if event.key == pygame.K_LEFT and self.volume.press() == 1: newVolume = self.volume.left() for snd in self.sounds: snd.set_volume(newVolume) # set new volume # newVolume = self.sounds[0].get_volume() - .1 # get current volume and increment # if newVolume < 0.: # if it exceeds the maximum # newVolume = 0. # # set now for every sound object we have # for snd in self.sounds: # snd.set_volume(newVolume) # set new volume # # save new volume to file # pickle.dump( {"sound": self.sounds[0].get_volume(), # "music": pygame.mixer.music.get_volume()}, # open( "volume.p", "wb" ) ) # =================================================================== # Credits============================================================= if self.gameState == "credits" and wasPressedNow == 0: if event.type == QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE or event.key == pygame.K_RETURN: self.gameState = "menu" # return to menu else: pass # throw exception # =================================================================== # Game =============================================================== elif self.gameState == "game": if event.type == QUIT: pygame.quit() sys.exit() # only on KEYDOWN event if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: x = self.userShip.rect.x y = self.userShip.rect.y self.laserSprites.add(Laser(x+12,y+28)) self.laserSnd.play() elif event.key == pygame.K_ESCAPE: self.gameState = "pause" # =================================================================== # Game Over ========================================================== elif self.gameState == "gameOver": if event.type == QUIT: pygame.quit() sys.exit() # only on KEYDOWN event - restart game with return or quit with escape if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: self.__init__() self.gameState = "game" elif event.key == pygame.K_ESCAPE: pygame.quit() sys.exit() else: pass # throw exception! # =================================================================== def keys(self,keys): # Game ============================================================== if self.gameState == "game": if keys[pygame.K_UP]: if self.userShip.rect.y >= 0: # prevent sprite from leaving window self.userShip.up() if keys[pygame.K_DOWN]: if self.userShip.rect.y + self.userShip.rect.height <= WINDOW_HEIGHT: # prevent sprite from leaving window self.userShip.down() if keys[pygame.K_LEFT]: if self.userShip.rect.x >= 0: # prevent sprite from leaving window self.userShip.left() if keys[pygame.K_RIGHT]: if self.userShip.rect.x + self.userShip.rect.width <= WINDOW_WIDTH: # prevent sprite from leaving window self.userShip.right() # =================================================================== def update(self): # Menu =============================================================== if self.gameState == "menu": pass # ==================================================================== # Pause ============================================================== if self.gameState == "pause": pass # ==================================================================== # Volume ============================================================== if self.gameState == "volume": pass # ==================================================================== # Credits ============================================================ if self.gameState == "credits": pass # ==================================================================== # Game =============================================================== elif self.gameState == "game": # Spawning ==================================================== # Spawn X001 enemy ships at random in a random y position # Probability: 1 in 60 per frame. if randint(1,60) == 1: # create temporary instance so we can grab the height of the sprite enemyObj = EnemyShipX001(WINDOW_WIDTH, 0,-6) # random y position on the screen enemyObj.rect.y = randint(0, WINDOW_HEIGHT - enemyObj.rect.height) self.aiSprites.add(enemyObj) # Spawn X002 enemy ships at random in a random y position # Probability: 1 in 120 per frame. if randint(1,120) == 1: # create temporary instance so we can grab the height of the sprite enemyObj = EnemyShipX002(WINDOW_WIDTH, 0,-4) # random y position on the screen enemyObj.rect.y = randint(0, WINDOW_HEIGHT - enemyObj.rect.height) self.aiSprites.add(enemyObj) # Spawn X003 enemy ships at random in a random y position # Probability: 1 in 120 per frame. if randint(1,120) == 1: # create temporary instance so we can grab the height of the sprite enemyObj = EnemyShipX003(WINDOW_WIDTH, 0,-4) # random y position on the screen enemyObj.yInitial = randint(0, WINDOW_HEIGHT - enemyObj.rect.height) enemyObj.rect.y = enemyObj.yInitial self.aiSprites.add(enemyObj) # ============================================================= # Movement ==================================================== # Move enemy ships forward according to their speed for enemy in self.aiSprites: enemy.update() # Move lasers forward according to their speed for laser in self.laserSprites: laser.update() #Move powerUps forward according to their speed for powerUp in self.powerUpSprites: powerUp.update() # ============================================================= # Erasing ===================================================== # Erase lasers that are out of the screen for laser in self.laserSprites: if laser.rect.x > WINDOW_WIDTH: self.laserSprites.remove(laser) # Erase enemy ships that are out of the screen for enemy in self.aiSprites: if enemy.rect.x < -10: self.aiSprites.remove(enemy) # Erase powerUps that are out of the screen for powerUp in self.powerUpSprites: if powerUp.rect.x < -10: self.powerUpSprites.remove(powerUp) # ============================================================= # Collisions ================================================== # check for collisions between user lasers and enemy sprites for laser in self.laserSprites: enemyHitList = pygame.sprite.spritecollide(laser,self.aiSprites,True) # if there was a collision if enemyHitList: self.laserSprites.remove(laser) # remove laser self.explodeSnd.play() # iterate over all enemy ships that collided for enemy in enemyHitList: thereIsPowerUp = 0 # enemy ship has not spawned power up self.score = self.score + enemy.score # add to score # Spawn Health 25 at random in the place of destroyed enemy ship # Probability: 1 per 50 destroyed enemies if randint(1,50) == 1: # create temporary instance so we can grab the height of the sprite powerUpObj = Health25(WINDOW_WIDTH, 0,-5) powerUpObj.rect.x = enemy.rect.x powerUpObj.rect.y = enemy.rect.y self.powerUpSprites.add(powerUpObj) thereIsPowerUp = 1 # to prevent enemy ship from spawning two powerups # Spawn Health 100 random in the place of destroyed enemy ship # but only if enemy ship has not spawned another powerUp # Probability: 1 per 125 destroyed enemies if randint(1,125) == 1 and thereIsPowerUp != 1: # create temporary instance so we can grab the height of the sprite powerUpObj = Health100(WINDOW_WIDTH, 0,-5) powerUpObj.rect.x = enemy.rect.x powerUpObj.rect.y = enemy.rect.y self.powerUpSprites.add(powerUpObj) # check for collisions between enemyShips and the user for enemy in self.aiSprites: userHit = pygame.sprite.spritecollide(enemy,self.userSprites,False, pygame.sprite.collide_mask) # if there was a collision if userHit: self.aiSprites.remove(enemy) # remove object self.userShip.shield -= 25 self.score = self.score + enemy.score # add to score self.explodeSnd.play() # check for collisions between powerUps and the user for powerUp in self.powerUpSprites: userHit = pygame.sprite.spritecollide(powerUp,self.userSprites,False) # if there was a collision if userHit: self.powerUpSprites.remove(powerUp) # remove object powerUp.pickUp(self.userShip) self.powerUpSnd.play() # no sound yet!! # ============================================================= # if user is dead if self.userShip.shield <= 0: self.userShip.shield = 0 # round shield to 0 self.gameState = "gameOver" # change state to gameOver # ==================================================================== # Game Over ========================================================== elif self.gameState == "gameOver": pass # ==================================================================== else: pass # throw exception! def draw(self,screen): # Menu =============================================================== if self.gameState == "menu": self.menu.draw(screen) # ==================================================================== # Pause ============================================================== if self.gameState == "pause": self.pause.draw(screen) # ==================================================================== # Volume ============================================================= if self.gameState == "volume": self.volume.draw(screen) # ==================================================================== # Credits ============================================================ if self.gameState == "credits": self.credits.draw(screen) # ==================================================================== # Game =============================================================== elif self.gameState == "game": # erase screen screen.fill(BLACK) # draw background - since the background is scrolling # we shall draw two side by side to prevent the background from ending # this way it repeats itself screen.blit(self.backg.image,(self.backg.x,self.backg.y)) screen.blit(self.backg.image,(self.backg.x + self.backg.width,self.backg.y)) # draw sprites onto the screen self.userSprites.draw(screen) self.laserSprites.draw(screen) self.aiSprites.draw(screen) self.powerUpSprites.draw(screen) # drawing text font = pygame.font.SysFont("Arial", 25) shieldTxt = font.render("Shield: " + str(self.userShip.shield), True, WHITE) scoreTxt = font.render("Score: " + str(self.score), True, WHITE) screen.blit(shieldTxt, [0,0]) screen.blit(scoreTxt, [0,30]) # animations self.backg.scroll(1) # update background self.userShip.animate() # update animation for enemy in self.aiSprites: enemy.animate() # update animation for powerUp in self.powerUpSprites: powerUp.animate() # ==================================================================== # Game Over ========================================================== elif self.gameState == "gameOver": # display game over and continue text font80 = pygame.font.SysFont("Arial", 80) font30 = pygame.font.SysFont("Arial", 30) gameOverTxt = font80.render("Game Over!", True, WHITE) continueTxt = font30.render("(Press Enter to restart, Escape to exit)", True, WHITE) screen.blit(gameOverTxt, [WINDOW_WIDTH/2-gameOverTxt.get_width()/2, WINDOW_HEIGHT/2-gameOverTxt.get_height()/2]) screen.blit(continueTxt, [WINDOW_WIDTH/2-continueTxt.get_width()/2, WINDOW_HEIGHT/2-continueTxt.get_height()/2+55]) pygame.display.update() else: pass # throw exception!!
def __init__(self): # variables ----------------------------------------------- # load background self.backg = Background(BKG_FOLDER + "stars.png") # set initial score self.score = 0 # load sound and music volume from file # if there's a problem with the file, simply create a new one with default values try: volume = pickle.load( open( "volume.p", "rb" ) ) except: volume = { "sound": 100, "music": 30 } pickle.dump( volume, open( "volume.p", "wb" ) ) # sounds self.laserSnd = pygame.mixer.Sound(SND_FOLDER + "laser.wav") self.explodeSnd = pygame.mixer.Sound(SND_FOLDER + "explosion.wav") self.powerUpSnd = pygame.mixer.Sound(SND_FOLDER + "powerUp.wav") # put everything into a list so it's easier to change the volume # the list elements are the same objects as the initial ones # as python copies by reference and not by value (I would have # preferred to use pointers, to avoid ambiguity, but oh well...) self.sounds = [self.laserSnd,self.explodeSnd,self.powerUpSnd] # set volume for all sound objects for snd in self.sounds: snd.set_volume(volume["sound"]/100.) # set new volume # music self.music = pygame.mixer.music.load(MUS_FOLDER + "reachingForTheSun.mp3") pygame.mixer.music.play(-1) # loop pygame.mixer.music.set_volume(volume["music"]/100.) # creating user ship self.userShip = ShipY001() self.userShip.speed = 10 # group of all sprites self.userSprites = pygame.sprite.Group() self.laserSprites = pygame.sprite.Group() self.aiSprites = pygame.sprite.Group() self.powerUpSprites = pygame.sprite.Group() # add to groups self.userSprites.add(self.userShip) # Creating main menu self.menu = Menu(["Quit","Credits","Volume","Play"],self.backg) # Creating pause menu (could be generated later, but shouldn't impact performance) self.pause = Menu(["Quit","Volume","Restart","Continue"],self.backg) # Creating volume menu (could be generated later, but shouldn't impact performance) self.volume = Volume(self.backg,volume) self.volumeBack = 0 # some stupid flag to tell us whether we came from the main menu # of from the pause menu # Creating credits self.credits = Credits(["Sound: Obtained from Freesound", "Music: 'Reaching for the Sun' by Deshiel and Bacon92", "Graphics: Filipa Silva", "Code: Alexandre Lopes"], self.backg) # gameState # Available states: menu, credits ,game, gameOver self.gameState = "menu"
def create_object(self, data): ro = self.rendering_options.create_object() sm = self.surface_model if sm: from SimpleSession import modelOffset model_id = (sm.id + modelOffset, sm.subid) else: model_id = None vlist = [] from volume import Volume if self.version >= 3: v = Volume(data[0], self.region, ro, model_id) vlist.append(v) if self.version >= 6: sid = self.session_volume_id else: if self.version == 5: suffix = self.region_name else: suffix = self.name if suffix: sid = '%s %s' % (v.name, suffix) else: sid = v.name if sm.name.endswith(' ' + suffix): sm.name = sm.name[:-len(suffix)-1] v.session_volume_id = sid for attr in ('representation', 'surface_levels', 'surface_colors', 'surface_brightness_factor', 'transparency_factor', 'solid_levels', 'solid_colors', 'solid_brightness_factor', 'transparency_depth', 'default_rgba'): setattr(v, attr, getattr(self, attr)) else: for i,d in enumerate(data): v = Volume(d, self.region, ro, model_id) v.representation = self.representation self.component_display_parameters[i].restore_state(v) vlist.append(v) if self.name: sid = '%s %s' % (v.name, self.name) else: sid = v.name v.session_volume_id = sid if self.version <= 3: # Changed definition of transparency depth from length to fraction # in version 4. dsize = map(lambda a,b: a*b, v.data.step, v.data.size) v.transparency_depth /= min(dsize) som = self.solid_model for v in vlist: if sm or som: v.show() if sm: sm.restore_state(v.surface_model()) if som and v.solid: som.restore_state(v.solid.model()) if self.version >= 2: for v in vlist: self.region_list.restore_state(v.region_list) return vlist
def test_get_center_neighbors(): """test the get neighbor function""" volume = Volume(data=np.random.random((3, 3, 3))) neighbors = volume._get_neighbors((1, 1, 1)) actual_neighbors = [(0, 1, 1), (2, 1, 1), (1, 2, 1), (1, 0, 1), (1, 1, 0), (1, 1, 2)] npt.assert_array_equal(neighbors.sort(), actual_neighbors.sort())
#!/usr/bin/env python from volume import Volume for h in (2, 3, 4): for x in range(6): v = Volume(100) for i in range(100): for j in range(h): v.clear((i, 50 + j, 50)) for sb in range(-x, x + 1): v.clear((i, 51, 50 + sb)) print( "%d height tunnel with %d continuous side block=%s (Digs %d See %d)" % (h, x, v.score(), v.digs, v.getVisible()) ) print() for x in range(6): v = Volume(100) for i in range(100): for j in range(h): v.clear((i, 50 + j, 50)) if i % 2 == 0: for sb in range(-x, x + 1): v.clear((i, 51, 50 + sb)) print( "%d height tunnel with %d alternating side block=%s (Digs %d See %d)" % (h, x, v.score(), v.digs, v.getVisible()) ) print()
def create_snapmirrors_for(self, srcvol, defaults): """ Create snapmirror volumes for a source volume. """ log.debug("Attempting to create snapmirror for srcvol: %s", srcvol) # get the snapmirrorset for the volume for ref in srcvol.get_snapmirror_setrefs(): log.debug("Found reference: %s", ref) # Check that the reference refers to a defined snapmirrorset try: setobj = [ x for x in self.get_snapmirrorsets() if x.name == ref.name ][0] except IndexError: log.error("Cannot find snapmirrorset definition '%s'" % ref) raise KeyError("snapmirrorset not defined: '%s'" % ref) target_filername = setobj.targetfiler if target_filername is None: # No target filer specified, so use the first primary at a site other than the source # This auto-created DR snapmirrors, but may not be what you mean. target_filername = self.tree.xpath("site[not(@type = '%s')]/filer[@type = 'primary']/@name" % srcvol.filer.site.type)[0] log.warn("No destination for snapmirror provided, using '%s'" % target_filername) pass try: target_filer = [x for x in self.get_filers() if x.name == target_filername ][0] except IndexError: raise KeyError("Snapmirror target is an unknown filer name: '%s'" % target_filername) # Find the target aggregate. targetaggr = self.find_target_aggr(target_filer, setobj.targetaggregate, defaults) # target volume name is the src volume name with a 'r' suffix xmldata = """ <volume name="%s%s" type="snapmirrordst" usable="%s" raw="%s" snapreserve="%s" protocol="%s" />""" % ( srcvol.name, setobj.targetsuffix, srcvol.usable, srcvol.raw, srcvol.snapreserve, srcvol.protocol, ) node = etree.fromstring(xmldata) targetvol = Volume() targetvol.configure_from_node(node, defaults, targetaggr) targetaggr.add_child(targetvol) log.debug("Created snapmirror targetvol: %s", targetvol) for sched in setobj.get_snapmirrorschedules(): sm = SnapMirror(srcvol, targetvol, sched.minute, sched.hour, sched.dayofmonth, sched.dayofweek, ) self.snapmirrors.append(sm) log.debug("added snapmirror: %s", sm) pass
def create_snapvaults_for(self, srcvol, defaults): """ Create snapvault volumes for a source volume. """ log.debug("Attempting to create snapvault for srcvol: %s", srcvol) # get the snapvaultset for the volume # If the volume is of certain types, don't back them up # if srcvol.type in ['oraredo', 'oracm' ]: # log.info("Not backing up volume '%s' of type '%s'", srcvol.name, srcvol.type) # return # Create target volumes based on the snapvault definition for ref in srcvol.get_snapvault_setrefs(): log.debug("Found reference: %s", ref.name) try: log.debug("snapvaultsets: %s", [x.name for x in self.get_snapvaultsets()] ) setobj = [ x for x in self.get_snapvaultsets() if x.name == ref.name ][0] except IndexError: raise KeyError("Cannot find snapvaultset definition '%s'" % ref.name) # If a target volume has been pre-defined, we'll use that. # Otherwise, we'll invent one based on certain rules and settings. target_filername = setobj.targetfiler try: target_filer = [x for x in self.get_filers() if x.name == target_filername ][0] except IndexError: raise KeyError("SnapVault target is an unknown filer name: '%s'" % target_filername) # If the target volume name is specified, use that if setobj.targetvolume is not None: try: targetvol = [ x for x in target_filer.get_volumes() if x.name == setobj.targetvolume ][0] except IndexError: raise KeyError("SnapVault targetvolume '%s' does not exist" % setobj.targetvolume) log.debug("Found specific volume: %s", targetvol) # Set the type of the volume to be a snapvault destination targetvol.type='snapvaultdst' pass # otherwise, invent a target volume, and use that instead else: # Find the target aggregate for the snapvault targetaggr = self.find_target_aggr(target_filer, setobj.targetaggregate, defaults) # Figure out how much usable storage to allocate to the target volume if setobj.targetusable is None: # iSCSI is special, again. Grr. if srcvol.protocol == 'iscsi': setobj.targetusable = srcvol.iscsi_usable * setobj.multiplier else: log.debug("usable: %f", srcvol.usable) log.debug("multiplier: %f", setobj.multiplier) setobj.targetusable = srcvol.usable * setobj.multiplier pass # target volume name is the src volume name with a 'b' suffix xmldata = """ <volume name="%s%s" type="snapvaultdst" usable="%s" raw="%s" snapreserve="%s" protocol="%s" />""" % ( srcvol.name, setobj.targetsuffix, setobj.targetusable, setobj.targetusable, 0, srcvol.protocol, ) node = etree.fromstring(xmldata) targetvol = Volume() targetvol.configure_from_node(node, defaults, targetaggr) targetaggr.add_child(targetvol) # end determination of target volume log.debug("Created snapvault targetvol: %s", targetvol) # If the target volume or aggregate are actually defined in # the XML, and use those settings for autosize and autodelete. #targetvol = self.set_volume_autosize(targetvol, targetvol.filer.name, targetvol.aggregate) #targetvol = self.set_volume_autodelete(targetvol, targetvol.filer.name, targetvol.aggregate) # Add the snapvaults themselves if len(setobj.get_snapvaultdefs()) == 0: log.warn("No snapvault defininitions provided for snapvaultset") pass log.debug("snapdefs: %s", setobj.get_snapvaultdefs() ) for svdef in setobj.get_snapvaultdefs(): sv = SnapVault(srcvol, targetvol, svdef.basename, svdef.snapschedule, svdef.snapvaultschedule, ) #srcvol.snapvaults.append(sv) #targetvol.snapvaults.append(sv) log.debug("Added snapvault: %s", sv)