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)
