def clicke_(self):
global path3
name=self.text_name.text()
if name.strip()!='':
f=open('write_data.txt','r')
lines = f.readlines()
id = len(lines)
f.close()
id+=1
create.create(id,name)
path2=os.path.join("dataSet/"+str(id))
path3=os.path.join(path2,name)
Exist=os.path.exists(path3)
print "Exist",Exist
if not Exist:
os.makedirs(path3)
else:
print "创建失败"
Exist=os.path.exists(path3)
if Exist:
print "不存在"
path3=os.path.join(path2,"Sql/")
os.makedirs(path3)
Exist=os.path.exists(path3)
if Exist:
print "已建立"
self.accept()
A=Face_cv()
A.show()
A.cap_()
else:
QMessageBox.information(self,"无输入","请输入姓名：")
def rebuild(self):
self.w.start_element("p")
try:
create(self.posts_folder, self.theme_folder,
self.process_command, self.sync_command)
except StaticcmsError, e:
self.w.text_node(str(e))
def do_create(args):
"""Create a droplet based on configuration"""
config = Configuration()
if not config.read_config(args.config_file):
return False
create(config)
return True
def main():
picpath = input('please enter pictures direction as "C:\\folder" format:')
annpath = input(
'please enter annotation file path as "C:\\folder" format:')
for file in os.listdir(picpath):
list.append(os.path.join(picpath, file))
for path in list:
create(path, annpath)
def clicke_(self):
name = self.text_name.text()
f = open('write_data.txt', 'r')
lines = f.readlines()
id = len(lines)
f.close()
id += 1
create.create(id, name)
trainer.train()
def init():
api_token = os.getenv('API_TOKEN')
okta_root_url = os.getenv('OKTA_ROOT_URL')
group_id = os.getenv('GROUP_ID')
okta_headers = {'Authorization': 'SSWS ' + api_token}
url = '{}/api/v1/groups/{}/users'.format(okta_root_url, group_id)
response = requests.get(url, headers=okta_headers)
response.raise_for_status()
response_data = response.json()
create(response_data)
def dispatch(intent_request):
"""
Called when the user specifies an intent for this bot.
"""
# logger.debug('dispatch userId={}, intentName={}'.format(intent_request['userId'], intent_request['currentIntent']['name']))
intent_name = intent_request['currentIntent']['name']
print intent_name
# # Dispatch to your bot's intent handlers
if intent_name == SCALAR_RETRIEVE:
return scalarCellRetrievalIntent.scalarCellRetrieval(intent_request)
if intent_name == LIST_RETRIEVE:
return ListRetrievalIntent.listRetrieval(intent_request)
# elif intent_name == WF_ACTION:
# return perform_wf_action(intent_request)
# elif intent_name == HELP_NAVIGATE:
# return help_navigate(intent_request)
# elif intent_name == HELP_TICKET:
# return help_ticket(intent_request)
elif intent_name == NAVIGATE:
return NavigateIntent.navigate(intent_request)
elif intent_name == CREATE:
return CreateIntent.create(intent_request)
elif intent_name == UPDATE:
return UpdateIntent.update(intent_request)
# elif intent_name == SAVE_TO_WORKSPACE:
# return save_to_workspace(intent_request)
elif intent_name is None:
#raise Exception('Intent not found')
print 'ff'
else:
raise Exception('Intent with name ' + intent_name + ' not supported')
def main():
main_command = sys.argv[1]
name = sys.argv[2]
actions = sys.argv[3:]
if main_command == "create" or main_command == "c":
create("./" + name);
elif main_command == "generate" or main_command == "g":
second_command = sys.argv[2]
name = sys.argv[3]
if second_command == "component" or second_command == "comp":
generate.component(name)
elif second_command == "container" or second_command == "cont":
generate.container(name)
elif main_command == "scaffold" or main_command == "s":
scaffold(name, actions)
def main():
quit = "y"
while (quit == 'y' or quit == 'Y'):
x = PrettyTable(["A R A B I D O P S I S T H A L I A N A D A T A B A S E"])
x.align["A R A B I D O P S I S T H A L I A N A D A T A B A S E"] = "l"
x.padding_width = 1
x.add_row(["1. Create the Genes table"])
x.add_row(["2. Display the Genes"])
x.add_row(["3. Insert a new Gene"])
x.add_row(["4. Delete a Gene"])
x.add_row(["5. Blast a Gene"])
print x
## Get input ###
choice = raw_input('Enter your choice [1-5] : ')
### Convert string to int type ##
choice = int(choice)
### Take action as per selected menu-option ###
if choice == 1:
create.create() #this will create the tables and popululate the data
elif choice == 2:
display.display() # display both the tables from the database
elif choice == 3:
insert.insert() # insert a new gene record in the database
elif choice == 4:
delete.delete() # delete a gene record from the database
elif choice == 5:
name = raw_input("Please enter the name of the gene to perform blast: ")
Blast.fn(name) # Calls the BLAST module
Blast.show() # Calls the module that prints image downloaded from Google Search
else: ## default ##
print ("Invalid input. Please enter the correct input...")
quit = raw_input('Do you wanna Continue : ')
def create_plate_from_dataframe(dataframe,plate_name,project_name,time_column=None,data_columns=None,useColumnsForNumber=False,time_parse=None):
"""Build a plate from a dataframe.
Create a plate from the provided dataframe, copying data into the associated data_table.
Specifics of which columns of the dataframe to use, for time and od, are optional arguments.
A function for converting the time column into the timedelta type is another optional argument.
Args:
dataframe: Pandas dataframe to be copied into the database
plate_name: name for the new plate being created
time_column: integer index of column to use for time values
data_columns: array of integers to use as indices for OD data
useColumnsForNumber: if true, use the column names to specify the well number and column names in data_table
time_parse: function used to convert time column values into timedelta
Returns:
(plate, wells, data_table): The newly created plate, its wells, and data_table with copied data from the dataframe."""
if time_column is None:
time_column = 0
if time_parse:
dataframe.iloc[:,time_column] = time_parse(dataframe.iloc[:,time_column])
if data_columns is None:
data_columns = range(dataframe.shape[1])
data_columns.remove(time_column)
assert len(data_columns) + 1 <= dataframe.shape[1], 'too many columns specified!'
project = session.query(models.Project).filter(models.Project.name==project_name).one_or_none()
if project is None:
project = create.create(project={'name':project_name})
plate = models.Plate(name=plate_name,project=project)
session.add(plate)
session.commit()
numbers = range(len(data_columns))
if useColumnsForNumber:
numbers = dataframe.columns[data_columns]
wells = [models.Well(plate=plate,plate_number=n) for n in numbers]
session.add_all(wells)
session.commit()
table = create_plate_data_table(plate)
column_names = [str(x) for x in data_columns]
if useColumnsForNumber:
column_names = [str(dataframe.columns[i]) for i in data_columns]
copy_plate_dataframe_to_table(dataframe,table,data_columns,column_names)
return plate,wells,table
def __init__(self, remoteShell, domainAdmin="admin", domain=None):
self.remoteShell = remoteShell
self.vastoolPath = "/opt/quest/bin/vastool"
self.domainAdmin = domainAdmin
self.defaultDomain = domain
self.info = info.info(self.run)
self.flush = flush.flush(self.run)
self.create = create.create(self.run, self.defaultDomain)
self.delete = delete.delete(self.run)
self.timesync = timesync.timesync(self.run)
self.nss = nss.nss(self.run)
self.group = group.group(self.run)
self.isvas = isvas.isvas(self.run)
self.list = list.list(self.run)
self.auth = auth.auth(self.run, self.defaultDomain)
self.cache = cache.cache(self.run)
self.configure = configure.configure(self.run)
self.configureVas = configureVas.configureVas(self.run)
self.schema = schema.schema(self.run)
self.merge = merge.merge(self.run)
self.unmerge = unmerge.unmerge(self.run)
self.user = User.user(self.run)
self.ktutil = ktutil.ktutil(self.run)
self.load = load.load(self.run)
self._license = License.License(self.run)
self.License = self._license.License
self.parseLicense = self._license.parseLicense
self.compareLicenses = self._license.compareLicenses
#self.vasUtilities = vasUtilities.vasUtilities(self.remoteShell)
self.unconfigure = unconfigure.unconfigure(self.run)
self.nssdiag = nssdiag(self.run)
isinstance(self.info, info.info)
isinstance(self.flush, flush.flush)
isinstance(self.create, create.create)
isinstance(self.delete, delete.delete)
isinstance(self.timesync, timesync.timesync)
isinstance(self.nss, nss.nss)
isinstance(self.group, group.group)
isinstance(self.isvas, isvas.isvas)
isinstance(self.list, list.list)
isinstance(self.auth, auth.auth)
isinstance(self.cache, cache.cache)
isinstance(self.configure, configure.configure)
isinstance(self.configureVas, configureVas.configureVas)
isinstance(self.schema, schema.schema)
isinstance(self.merge, merge.merge)
isinstance(self.unmerge, unmerge.unmerge)
isinstance(self.user, User.user)
isinstance(self.ktutil, ktutil.ktutil)
isinstance(self.load, load.load)
#isinstance(self.vasUtilities, vasUtilities.vasUtilities)
isinstance(self.unconfigure, unconfigure.unconfigure)
isinstance(self.nssdiag, nssdiag)
def create_as_select(table_name, select_fields):
# out_file, fields, original_table_name, where, group, having, order = select_fields
assert select_fields[0] is None
original_table = Table(select_fields[2])
# print(original_table.get_final_field(select_fields[1]))
final_fields = []
fields, nicknames, needed_fields = original_table.get_final_field(
select_fields[1])
for field in fields:
final_fields.append(
(field, original_table.type_from_name(nicknames[field])))
# final_fields = [(x, original_table.name2type[x]) for x in original_table.get_final_field(select_fields[1])[0]]
# print(final_fields)
create(table_name, final_fields, False)
select_fields = list(select_fields)
select_fields[0] = "tmp.txt"
select_fields = tuple(select_fields)
original_table.select(*(select_fields[:2] + select_fields[3:]))
load("tmp.txt", table_name, 0)
def main():
menu = {
'вставити': insert,
'вивести': read,
'відредагувати': update,
'видалити': delete
}
tb = None
conn = mysql_connect()
cur = conn.cursor()
while True:
tb = input_tb() if tb == None else new_tb(tb)
all_tbs = table_check(cur, conn, tb)
if tb not in all_tbs:
ans = input("Такої таблиці не існує. Створити?так/ні: ")
if ans == 'так':
create(cur, conn, tb)
else:
tb = None
else:
print("Виберіть операцію: ")
for key in menu.keys():
print("-> " + key)
ans = input(">>")
menu[ans](cur, conn, tb)
if ans == 'видалити':
tb = None
ans = input("Продовжити роботу?так/ні: ")
if ans == 'ні':
break
conn.close()
return
def run(self):
created = create(self.image, self.flavor, self.network, self.count)
disp_list = created.run()
print disp_list
if len(disp_list[0]['server']) > 0:
deleted = delete(disp_list[0]['server'], self.count)
disp_list.append(deleted.run()[0])
#x = PrettyTable(["Task Name", "Minimum Time", "Average Time", "Maximum Time"])
#x.add_row(["nova.create",dict_values['min'], dict_values['avg'], dict_values['max']])
#x.add_row(["nova.delete",dict_delete['min'], dict_delete['avg'], dict_delete['max']])
#x.add_row(["TOTAL", TOTAL_MIN, TOTAL_AVG, TOTAL_MAX])
#print x
print disp_list
return disp_list
def run(self):
created = create(self.image, self.flavor, self.network, self.count)
server_name = created.run()
time.sleep(10)
volume = create_volume(self.size)
volume_name = volume.run()
time.sleep(10)
comm = "openstack server add volume " + server_name + " " + volume_name
os.system(comm)
time.sleep(10)
print "Volume: " + volume_name + " attached to server " + server_name
deleted = delete(server_name)
deleted.run()
del_volume = delete_volume(volume_name)
del_volume.run()
def create_item():
# test creating an item
request = {
'body':
json.dumps({
'name': 'Headress of the Ring',
'description': 'Very snazzy headware',
'slot': 1,
'quality': 3,
'stamina': 21,
'crit_chance': .018,
'damage': 25
})
}
item = create(request, None)
return item
def index(request):
template = loader.get_template('index.html')
book_name = ''
result = ''
if request.method == "POST":
book_name = request.POST.get("book_name")
cwd = os.getcwd()
if book_name != '':
result = search.search_ask(book_name)
real_name = create.create(book_name)
print(cwd)
file_path = os.path.join(cwd, real_name)
return download(request, file_path, real_name)
context = {'return_value': book_name, 'result_1': result, 'cwd': cwd}
return HttpResponse(template.render(context, request))
def lineReceived(self, line):
if self.status < 3: #checking name / password
login(self, line)
elif self.status == 3: #creating a character
if create(self.player, line, self.new): #if create dialogue finished
self.status = 4
elif self.status == 4:
self.factory.playerObjects.append(self.player)
self.factory.broadOthers(self, "\033[01;35m" + self.player.name+ " has logged in." + "\033[01;37m")
self.sendLine("\033[01;35m" + "Welcome to the world, "+ self.player.name + "\033[01;37m")
self.status = 5
self.player.updateRoom()
print "ClientProtocols: ", len( self.factory.clientProtocols )
elif self.status == 5: #now in game
self.player.handle(line)
def main(crop_length=CROP_LENGTH, crop_width=CROP_WIDTH):
name = "Avion.jpg"
# OPEN IMAGE
image = Image.open(PATH + name)
tab = np.array(image)
# CREATE COLOR MOSAIC
tab_sub = reduction.get_sub_tab(tab, crop_length, crop_width)
dam = slicer.damier(tab, crop_length, crop_width)
# CHOSE IMAGES FROM COLORS
images = recover.get_images(tab_sub)
# CREATE FINAL IMAGE FROM IMAGES
final, err = create.create(images, crop_length, crop_width)
mosa = Image.fromarray(final)
mosa.show()
def checkurl(server,url,typefile):
host_name = url
if '?' in url:
host_name, arguments = url.split('?')
components = host_name.split('/')
if 'attach' in components:
global VOLUME_LIST
final_argument_list = []
arg_split = arguments.split('=')
final_argument_list.append(arg_split[1])
args=final_argument_list
vid=int(args[0])
volid=int(args[1])-1
machid=data.vmdetails[vid][2]
m_addr=data.pm[machid][0]
path = 'remote+ssh://'+m_addr+'/system'
vm_na=data.vmdetails[vid][0]
if int(VOLUME_LIST[volid][2])==0: #that volume is not already attached to something
try:
connect = libvirt.open(path)
dom=connect.lookupByName(vm_na)
f=open("/etc/ceph/ceph.conf",'r')
l=f.readlines()
l1=f.split("\n")
host=l1[2].split('=')[1]
f.close()
xml="<disk type='network' device='disk'> \
<source protocol='rbd' name='rbd/"+VOLUME_LIST[volid][0]+"'> \
<host name="+str(host)+" port='6789'/> \
</source> \
<target dev='hdb' bus='virtio'/> \
</disk>"
dom.attachDevice(xml)
server.wfile.write(json_out({"status":1}))
VOLUME_LIST[volid][2]=1
VOLUME_LIST[volid][3]=int(vid)
except:
server.wfile.write(json_out({"status":0}))
else:
server.wfile.write(json_out({"Storage Already attached to some machine so! status":0}))
if 'detach' in components:
global VOLUME_LIST
final_argument_list = []
arg_split = arguments.split('=')
final_argument_list.append(arg_split[1])
args=final_argument_list
#vid=int(args[0])
volid=int(args[0])-1
if volid in VOLUME_LIST:
if VOLUME_LIST[volid][2]==1:
vid=VOLUME_LIST[volid][3]
machid=data.vmdetails[vid][2]
m_addr=data.pm[machid][0]
path = 'remote+ssh://'+m_addr+'/system'
vm_na=data.vmdetails[volid][0]
try:
connect = libvirt.open(path)
dom=connect.lookupByName(vm_na)
f=open("/etc/ceph/ceph.conf",'r')
l=f.readlines()
l1=f.split("\n")
host=l1[2].split('=')[1]
f.close()
xml="<disk type='network' device='disk'> \
<source protocol='rbd' name='rbd/"+VOLUME_LIST[volid][0]+"'> \
<host name="+str(host)+" port='6789'/> \
</source> \
<target dev='hdb' bus='virtio'/> \
</disk>"
dom.detachDevice(xml)
server.wfile.write(json_out({"status":1}))
VOLUME_LIST[vid][2]=0
VOLUME_LIST[vid][3]=int(vid)
except:
server.wfile.write(json_out({"status":0}))
else:
server.wfile.write(json_out({"status":0}))
else:
server.wfile.write(json_out({"status":0}))
if 'create' in components:
final_argument_list = []
arg_split = arguments.split('&')
if 'volume' in components:
for i in xrange(0,2):
final_argument_list.append((arg_split[i].split('='))[1])
print final_argument_list
data.server_header(server,final_argument_list)
global VOLUME_LIST
args=final_argument_list
volume_name = str(args[0])
volume_size = args[1]
actual_size = str(int(float(volume_size)*(1024**3))) #as size was mentioned in GB's so conversion into bytes
#os.system('sudo rbd create %s --size %s'%(str(volume_name),str(actual_size)))
try:
global MID
rbdInstance.create(ioctx,volume_name,int(actual_size))
os.system('sudo rbd map %s --pool %s --name client.admin'%(volume_name,str(POOL_NAME)));
#os.system('sudo rbd create ' + volume_name + ' --size ' + volume_size +' -k /etc/ceph/ceph.client.admin.keyring')
#rbdInstance.create(ioctx,str(volume_name),actual_size)
#os.system('sudo modprobe rbd')
#os.system('sudo rbd map ' + volume_name + ' --pool rbd --name client.admin -k /etc/ceph/ceph.client.admin.keyring')
#os.system('sudo mkfs.ext4 -m0 /dev/rbd/rbd/' + volume_name)
#os.system('sudo rbd map %s --pool %s --name client.admin'%(str(volume_name),str(POOL_NAME)));
global VOLUME_LIST
MID=MID+1
volume_id=MID
VOLUME_LIST[int(volume_id)]=[volume_name,volume_size,0,0]
print "list is",VOLUME_LIST
server.wfile.write(json_out({"volumeid":volume_id+1}))
except:
server.wfile.write(json_out({"volumeid":'0'}))
else:
for i in xrange(0,3):
final_argument_list.append((arg_split[i].split('='))[1])
print final_argument_list
create.create(server,final_argument_list)
#return jsonify(volumeid=volume_id)
#else:
# create.create(server,final_argument_list)
if 'destroy' in components:
final_argument_list = []
arg_split = arguments.split('=')
if 'volume' in components:
final_argument_list.append(arg_split[1])
global VOLUME_LIST
args=final_argument_list
volume_id = int(args[0])-1
if volume_id in VOLUME_LIST:
volume_name=str(VOLUME_LIST[int(volume_id)][0])
else:
server.wfile.write(json_out({"status":'0'}))
try:
os.system('sudo rbd unmap /dev/rbd/%s/%s'%(POOL_NAME,volume_name))
rbdInstance.remove(ioctx,volume_name)
#os.system("sudo rbd rm %s"%(volume_name))
server.wfile.write(json_out({"status":'1'}))
del VOLUME_LIST[volume_id]
except:
server.wfile.write(json_out({"status":'0'}))
#rbdInstance.remove(ioctx,volume_name)
else:
final_argument_list.append(arg_split[1])
delete.destroy(server,final_argument_list)
pass
if 'types' in components:
data.server_header(server,200)
try:
f = typefile
fopen = open(f)
server.wfile.write(create.json_out(json.load(fopen)))
except Exception,e:
print str(e)
server.wfile.write(create.json_out({"status":0}))
def test_create_failure(self):
response = create.create(create_failure_body, '')
self.assertEqual(response['statusCode'], 400)
def test_create_success(self):
response = create.create(create_success_body, '')
self.assertEqual(response['statusCode'], 200)
def main():
dirPath = os.path.dirname(os.path.realpath(__file__))
# Fixes pip not able to find other included modules.
sys.path.append(os.path.abspath(dirPath))
# Print the version if only the -v option is added.
if(sys.argv[1:] == ['-v'] or sys.argv[1:] == ['-V']):
print(f'Auto-Editor version {version}\nPlease use --version instead.')
sys.exit()
if(sys.argv[1:] == []):
print('\nAuto-Editor is an automatic video/audio creator and editor.\n')
print('By default, it will detect silence and create a new video with ')
print('those sections cut out. By changing some of the options, you can')
print('export to a traditional editor like Premiere Pro and adjust the')
print('edits there, adjust the pacing of the cuts, and change the method')
print('of editing like using audio loudness and video motion to judge')
print('making cuts.')
print('\nRun:\n auto-editor --help\n\nTo get the list of options.\n')
sys.exit()
from vanparse import ParseOptions
from usefulFunctions import Log, Timer
subcommands = ['create', 'test', 'info', 'levels']
if(len(sys.argv) > 1 and sys.argv[1] in subcommands):
if(sys.argv[1] == 'create'):
from create import create, create_options
from usefulFunctions import FFmpeg
args = ParseOptions(sys.argv[2:], Log(), 'create', create_options())
ffmpeg = FFmpeg(dirPath, args.my_ffmpeg, True, Log())
create(ffmpeg, args.input, args.output_file, args.frame_rate, args.duration,
args.width, args.height, Log())
if(sys.argv[1] == 'test'):
from testAutoEditor import testAutoEditor
testAutoEditor()
if(sys.argv[1] == 'info'):
from info import getInfo, info_options
from usefulFunctions import FFmpeg, FFprobe
args = ParseOptions(sys.argv[2:], Log(), 'info', info_options())
log = Log()
ffmpeg = FFmpeg(dirPath, args.my_ffmpeg, False, log)
ffprobe = FFprobe(dirPath, args.my_ffmpeg, False, log)
getInfo(args.input, ffmpeg, ffprobe, args.fast, log)
if(sys.argv[1] == 'levels'):
from levels import levels, levels_options
from usefulFunctions import FFmpeg, FFprobe
args = ParseOptions(sys.argv[2:], Log(), 'levels', levels_options())
TEMP = tempfile.mkdtemp()
log = Log(temp=TEMP)
ffmpeg = FFmpeg(dirPath, args.my_ffmpeg, False, log)
ffprobe = FFprobe(dirPath, args.my_ffmpeg, False, log)
levels(args.input, args.track, args.output_file, ffmpeg, ffprobe, TEMP, log)
sys.exit()
else:
option_data = main_options()
args = ParseOptions(sys.argv[1:], Log(True), 'auto-editor', option_data)
timer = Timer(args.quiet)
del option_data
from usefulFunctions import FFmpeg, FFprobe, sep
ffmpeg = FFmpeg(dirPath, args.my_ffmpeg, args.show_ffmpeg_debug, Log())
ffprobe = FFprobe(dirPath, args.my_ffmpeg, args.show_ffmpeg_debug, Log())
# Stops "The file {file} does not exist." from showing.
if(args.export_as_clip_sequence):
args.no_open = True
makingDataFile = (args.export_to_premiere or args.export_to_resolve or
args.export_to_final_cut_pro or args.export_as_json)
is64bit = '64-bit' if sys.maxsize > 2**32 else '32-bit'
if(args.debug and args.input == []):
import platform
print('Python Version:', platform.python_version(), is64bit)
print('Platform:', platform.system(), platform.release())
print('Config File path:', dirPath + sep() + 'config.txt')
print('FFmpeg path:', ffmpeg.getPath())
print('FFmpeg version:', ffmpeg.getVersion())
print('Auto-Editor version', version)
sys.exit()
TEMP = tempfile.mkdtemp()
log = Log(args.debug, args.quiet, temp=TEMP)
log.debug(f'\n - Temp Directory: {TEMP}')
if(is64bit == '32-bit'):
log.warning('You have the 32-bit version of Python, which may lead to' \
'memory crashes.')
if(args.version):
print('Auto-Editor version', version)
sys.exit()
ffmpeg.updateLog(log)
ffprobe.updateLog(log)
from usefulFunctions import isLatestVersion
if(not args.quiet and not isLatestVersion(version, log)):
log.print('\nAuto-Editor is out of date. Run:\n')
log.print(' pip3 install -U auto-editor')
log.print('\nto upgrade to the latest version.\n')
from argsCheck import hardArgsCheck, softArgsCheck
hardArgsCheck(args, log)
args = softArgsCheck(args, log)
from validateInput import validInput
inputList = validInput(args.input, ffmpeg, args, log)
# Figure out the output file names.
def newOutputName(oldFile: str, audio, final_cut_pro, data, json) -> str:
dotIndex = oldFile.rfind('.')
print(oldFile)
if(json):
return oldFile[:dotIndex] + '.json'
if(final_cut_pro):
return oldFile[:dotIndex] + '.fcpxml'
if(data):
return oldFile[:dotIndex] + '.xml'
if(audio):
return oldFile[:dotIndex] + '_ALTERED.wav'
return oldFile[:dotIndex] + '_ALTERED' + oldFile[dotIndex:]
if(len(args.output_file) < len(inputList)):
for i in range(len(inputList) - len(args.output_file)):
args.output_file.append(newOutputName(inputList[i],
args.export_as_audio, args.export_to_final_cut_pro, makingDataFile,
args.export_as_json))
if(args.combine_files):
# Combine video files, then set input to 'combined.mp4'.
cmd = []
for fileref in inputList:
cmd.extend(['-i', fileref])
cmd.extend(['-filter_complex', f'[0:v]concat=n={len(inputList)}:v=1:a=1',
'-codec:v', 'h264', '-pix_fmt', 'yuv420p', '-strict', '-2',
f'{TEMP}{sep()}combined.mp4'])
ffmpeg.run(cmd)
del cmd
inputList = [f'{TEMP}{sep()}combined.mp4']
speeds = [args.silent_speed, args.video_speed]
if(args.cut_out != [] and 99999 not in speeds):
speeds.append(99999)
for item in args.set_speed_for_range:
if(item[0] not in speeds):
speeds.append(float(item[0]))
log.debug(f' - Speeds: {speeds}')
from wavfile import read
audioExtensions = ['.wav', '.mp3', '.m4a', '.aiff', '.flac', '.ogg', '.oga',
'.acc', '.nfa', '.mka']
sampleRate = None
for i, INPUT_FILE in enumerate(inputList):
if(len(inputList) > 1):
log.conwrite(f'Working on {INPUT_FILE}')
fileFormat = INPUT_FILE[INPUT_FILE.rfind('.'):]
chunks = None
if(fileFormat == '.json'):
log.debug('Reading .json file')
from makeCutList import readCutList
INPUT_FILE, chunks, speeds = readCutList(INPUT_FILE, version, log)
newOutput = newOutputName(INPUT_FILE, args.export_as_audio,
args.export_to_final_cut_pro, makingDataFile, False)
fileFormat = INPUT_FILE[INPUT_FILE.rfind('.'):]
else:
newOutput = args.output_file[i]
if(not os.path.isdir(INPUT_FILE) and '.' not in newOutput):
newOutput += INPUT_FILE[INPUT_FILE.rfind('.'):]
log.debug(f' - INPUT_FILE: {INPUT_FILE}')
log.debug(f' - newOutput: {newOutput}')
if(os.path.isfile(newOutput) and INPUT_FILE != newOutput):
log.debug(f' Removing already existing file: {newOutput}')
os.remove(newOutput)
if(args.sample_rate is None):
sampleRate = ffprobe.getSampleRate(INPUT_FILE)
if(sampleRate == 'N/A'):
sampleRate = '48000'
log.warning(f"Samplerate wasn't detected, so it will be set to {sampleRate}.")
else:
sampleRate = str(args.sample_rate)
log.debug(f' - sampleRate: {sampleRate}')
if(args.audio_bitrate is None):
if(INPUT_FILE.endswith('.mkv')):
# audio bitrate not supported in the mkv container.
audioBitrate = None
else:
audioBitrate = ffprobe.getPrettyBitrate(INPUT_FILE, 'a')
if(audioBitrate == 'N/A'):
log.warning("Couldn't automatically detect audio bitrate.")
audioBitrate = None
else:
audioBitrate = args.audio_bitrate
log.debug(f' - audioBitrate: {audioBitrate}')
audioData = None
audioFile = fileFormat in audioExtensions
if(audioFile):
if(args.force_fps_to is None):
fps = 30 # Audio files don't have frames, so give fps a dummy value.
else:
fps = args.force_fps_to
if(args.force_tracks_to is None):
tracks = 1
else:
tracks = args.force_tracks_to
cmd = ['-i', INPUT_FILE]
if(audioBitrate is not None):
cmd.extend(['-b:a', audioBitrate])
cmd.extend(['-ac', '2', '-ar', sampleRate, '-vn', f'{TEMP}{sep()}fastAud.wav'])
ffmpeg.run(cmd)
del cmd
sampleRate, audioData = read(f'{TEMP}{sep()}fastAud.wav')
else:
if(args.force_fps_to is not None):
fps = args.force_fps_to
elif(args.export_to_premiere or args.export_to_final_cut_pro or
args.export_to_resolve):
# Based on timebase.
fps = int(ffprobe.getFrameRate(INPUT_FILE))
else:
fps = ffprobe.getFrameRate(INPUT_FILE)
if(fps < 1):
log.error(f"{INPUT_FILE}: Frame rate cannot be below 1. fps: {fps}")
tracks = args.force_tracks_to
if(tracks is None):
tracks = ffprobe.getAudioTracks(INPUT_FILE)
if(args.cut_by_this_track >= tracks):
allTracks = ''
for trackNum in range(tracks):
allTracks += f'Track {trackNum}\n'
if(tracks == 1):
message = f'is only {tracks} track'
else:
message = f'are only {tracks} tracks'
log.error("You choose a track that doesn't exist.\n" \
f'There {message}.\n {allTracks}')
# Split audio tracks into: 0.wav, 1.wav, etc.
for trackNum in range(tracks):
cmd = ['-i', INPUT_FILE]
if(audioBitrate is not None):
cmd.extend(['-ab', audioBitrate])
cmd.extend(['-ac', '2', '-ar', sampleRate, '-map',
f'0:a:{trackNum}', f'{TEMP}{sep()}{trackNum}.wav'])
ffmpeg.run(cmd)
del cmd
# Check if the `--cut_by_all_tracks` flag has been set or not.
if(args.cut_by_all_tracks):
# Combine all audio tracks into one audio file, then read.
cmd = ['-i', INPUT_FILE, '-filter_complex',
f'[0:a]amix=inputs={tracks}:duration=longest', '-ar',
sampleRate, '-ac', '2', '-f', 'wav', f'{TEMP}{sep()}combined.wav']
ffmpeg.run(cmd)
sampleRate, audioData = read(f'{TEMP}{sep()}combined.wav')
del cmd
else:
# Read only one audio file.
if(os.path.isfile(f'{TEMP}{sep()}{args.cut_by_this_track}.wav')):
sampleRate, audioData = read(f'{TEMP}{sep()}{args.cut_by_this_track}.wav')
else:
log.bug('Audio track not found!')
log.debug(f' - Frame Rate: {fps}')
if(chunks is None):
from cutting import audioToHasLoud, motionDetection
audioList = None
motionList = None
if('audio' in args.edit_based_on):
log.debug('Analyzing audio volume.')
audioList = audioToHasLoud(audioData, sampleRate,
args.silent_threshold, fps, log)
if('motion' in args.edit_based_on):
log.debug('Analyzing video motion.')
motionList = motionDetection(INPUT_FILE, ffprobe,
args.motion_threshold, log, width=args.width,
dilates=args.dilates, blur=args.blur)
if(audioList is not None):
if(len(audioList) != len(motionList)):
log.debug(f'audioList Length: {len(audioList)}')
log.debug(f'motionList Length: {len(motionList)}')
if(len(audioList) > len(motionList)):
log.debug('Reducing the size of audioList to match motionList.')
audioList = audioList[:len(motionList)]
elif(len(motionList) > len(audioList)):
log.debug('Reducing the size of motionList to match audioList.')
motionList = motionList[:len(audioList)]
from cutting import combineArrs, applySpacingRules
hasLoud = combineArrs(audioList, motionList, args.edit_based_on, log)
del audioList, motionList
effects = []
if(args.zoom != []):
from cutting import applyZooms
effects += applyZooms(args.zoom, audioData, sampleRate, fps, log)
if(args.rectangle != []):
from cutting import applyRects
effects += applyRects(args.rectangle, audioData, sampleRate, fps, log)
chunks = applySpacingRules(hasLoud, speeds, fps, args, log)
del hasLoud
def isClip(chunk):
nonlocal speeds
return speeds[chunk[2]] != 99999
def getNumberOfCuts(chunks, speeds):
return len(list(filter(isClip, chunks)))
def getClips(chunks, speeds):
clips = []
for chunk in chunks:
if(isClip(chunk)):
clips.append([chunk[0], chunk[1], speeds[chunk[2]] * 100])
return clips
numCuts = getNumberOfCuts(chunks, speeds)
clips = getClips(chunks, speeds)
if(fps is None and not audioFile):
if(makingDataFile):
constantLoc = appendFileName(INPUT_FILE, '_constantFPS')
else:
constantLoc = f'{TEMP}{sep()}constantVid{fileFormat}'
ffmpeg.run(['-i', INPUT_FILE, '-filter:v', 'fps=fps=30', constantLoc])
INPUT_FILE = constantLoc
if(args.export_as_json):
from makeCutList import makeCutList
makeCutList(INPUT_FILE, newOutput, version, chunks, speeds, log)
continue
if(args.preview):
newOutput = None
from preview import preview
preview(INPUT_FILE, chunks, speeds, fps, audioFile, log)
continue
if(args.export_to_premiere or args.export_to_resolve):
from editor import editorXML
editorXML(INPUT_FILE, TEMP, newOutput, ffprobe, clips, chunks, tracks,
sampleRate, audioFile, args.export_to_resolve, fps, log)
continue
if(args.export_to_final_cut_pro):
from editor import fcpXML
fcpXML(INPUT_FILE, TEMP, newOutput, ffprobe, clips, chunks, tracks,
sampleRate, audioFile, fps, log)
continue
def makeAudioFile(input_, chunks, output):
from fastAudio import fastAudio, handleAudio, convertAudio
theFile = handleAudio(ffmpeg, input_, audioBitrate, str(sampleRate),
TEMP, log)
TEMP_FILE = f'{TEMP}{sep()}convert.wav'
fastAudio(theFile, TEMP_FILE, chunks, speeds, log, fps,
args.machine_readable_progress, args.no_progress)
convertAudio(ffmpeg, ffprobe, TEMP_FILE, input_, output, args, log)
if(audioFile):
if(args.export_as_clip_sequence):
i = 1
for item in chunks:
if(speeds[item[2]] == 99999):
continue
makeAudioFile(INPUT_FILE, [item], appendFileName(newOutput, f'-{i}'))
i += 1
else:
makeAudioFile(INPUT_FILE, chunks, newOutput)
continue
def makeVideoFile(input_, chunks, output):
from videoUtils import handleAudioTracks, muxVideo
continueVid = handleAudioTracks(ffmpeg, output, args, tracks, chunks, speeds,
fps, TEMP, log)
if(continueVid):
if(args.render == 'auto'):
if(args.zoom != [] or args.rectangle != []):
args.render = 'opencv'
else:
try:
import av
args.render = 'av'
except ImportError:
args.render = 'opencv'
log.debug(f'Using {args.render} method')
if(args.render == 'av'):
if(args.zoom != []):
log.error('Zoom effect is not supported on the av render method.')
if(args.rectangle != []):
log.error('Rectangle effect is not supported on the av render method.')
from renderVideo import renderAv
renderAv(ffmpeg, ffprobe, input_, args, chunks, speeds, fps,
TEMP, log)
if(args.render == 'opencv'):
from renderVideo import renderOpencv
renderOpencv(ffmpeg, ffprobe, input_, args, chunks, speeds, fps,
effects, TEMP, log)
# Now mix new audio(s) and the new video.
muxVideo(ffmpeg, output, args, tracks, TEMP, log)
if(output is not None and not os.path.isfile(output)):
log.bug(f'The file {output} was not created.')
if(args.export_as_clip_sequence):
i = 1
totalFrames = chunks[len(chunks) - 1][1]
speeds.append(99999) # guarantee we have a cut speed to work with.
for item in chunks:
if(speeds[item[2]] == 99999):
continue
makeVideoFile(INPUT_FILE, padChunk(item, totalFrames),
appendFileName(newOutput, f'-{i}'))
i += 1
else:
makeVideoFile(INPUT_FILE, chunks, newOutput)
if(not args.preview and not makingDataFile):
timer.stop()
if(not args.preview and makingDataFile):
from usefulFunctions import humanReadableTime
# Assume making each cut takes about 30 seconds.
timeSave = humanReadableTime(numCuts * 30)
s = 's' if numCuts != 1 else ''
log.print(f'Auto-Editor made {numCuts} cut{s}', end='')
log.print(f', which would have taken about {timeSave} if edited manually.')
if(not args.no_open):
from usefulFunctions import openWithSystemDefault
openWithSystemDefault(newOutput, log)
log.debug('Deleting temp dir')
try:
rmtree(TEMP)
except PermissionError:
from time import sleep
sleep(1)
try:
rmtree(TEMP)
except PermissionError:
log.debug('Failed to delete temp dir.')
from base import Node from create import create from output import output from reverse_output import reverse_output, reverse_output_recursively from reverse import reverse from delete import delete from append import append from delete_according_to_value import delete_according_to_value from insert import insert from sort import sort list = [4, 1, 5, 8, 3, 7, 4, 6, 2] head = create(list) print(head) output(head) reverse_output(head) reverse_output_recursively(head) head = reverse(head) print() output(head) delete(head, 2) output(head) append(head, 40) output(head) delete_according_to_value(head, 40) output(head)
def handle_single_problem(problem):
"""
Creates a machine learning model for a given problem.
problem - A Problem instance (django model)
"""
#This function is called by celery. This ensures that the database is not stuck in an old transaction
transaction.commit_unless_managed()
#Get prompt and essays from problem (needed to train a model)
prompt = problem.prompt
essays = problem.essay_set.filter(essay_type="train")
#Now, try to decode the grades from the essaygrade objects
essay_text = []
essay_grades = []
essay_text_vals = essays.values('essay_text')
for i in xrange(0,len(essays)):
try:
#Get an instructor score for a given essay (stored as a json string in DB) and convert to a list. Looks like [1,1]
#where each number denotes a score for a given target number
essay_grades.append(json.loads(essays[i].get_instructor_scored()[0].target_scores))
#If a grade could successfully be found, then add the essay text. Both lists need to be in sync.
essay_text.append(essay_text_vals[i]['essay_text'])
except:
log.exception("Could not get latest instructor scored for {0}".format(essays[i]))
try:
#This is needed to remove stray characters that could break the machine learning code
essay_text = [et.encode('ascii', 'ignore') for et in essay_text]
except:
error_message = "Could not correctly encode some submissions: {0}".format(essay_text)
log.exception(error_message)
return False, error_message
#Get the maximum target scores from the problem
first_len = len(json.loads(problem.max_target_scores))
for i in xrange(0,len(essay_grades)):
#All of the lists within the essay grade list (ie [[[1,1],[2,2]]) need to be the same length
if len(essay_grades[i])!=first_len:
error_message = "Problem with an instructor scored essay! {0}".format(essay_grades)
log.exception(error_message)
return False, error_message
#Too many essays can take a very long time to train and eat up system resources. Enforce a max.
# Accuracy increases logarithmically, anyways, so you dont lose much here.
if len(essay_text)>MAX_ESSAYS_TO_TRAIN_WITH:
essay_text = essay_text[:MAX_ESSAYS_TO_TRAIN_WITH]
essay_grades = essay_grades[:MAX_ESSAYS_TO_TRAIN_WITH]
graded_sub_count = len(essay_text)
#If there are too few essays, then don't train a model. Need a minimum to get any kind of accuracy.
if graded_sub_count < MIN_ESSAYS_TO_TRAIN_WITH:
error_message = "Too few too create a model for problem {0} need {1} only have {2}".format(problem, MIN_ESSAYS_TO_TRAIN_WITH, graded_sub_count)
log.error(error_message)
return False, error_message
#Loops through each potential target
for m in xrange(0,first_len):
#Gets all of the scores for this particular target
scores = [s[m] for s in essay_grades]
max_score = max(scores)
log.debug("Currently on location {0} in problem {1}".format(m, problem.id))
#Get paths to ml model from database
relative_model_path, full_model_path= ml_grading_util.get_model_path(problem,m)
#Get last created model for given location
transaction.commit_unless_managed()
success, latest_created_model=ml_grading_util.get_latest_created_model(problem,m)
if success:
sub_count_diff=graded_sub_count-latest_created_model.number_of_essays
else:
sub_count_diff = graded_sub_count
#Retrain if no model exists, or every 10 graded essays.
if not success or sub_count_diff>=10:
log.info("Starting to create a model because none exists or it is time to retrain.")
#Checks to see if another model creator process has started amodel for this location
success, model_started, created_model = ml_grading_util.check_if_model_started(problem)
#Checks to see if model was started a long time ago, and removes and retries if it was.
if model_started:
log.info("A model was started previously.")
now = timezone.now()
second_difference = (now - created_model.modified).total_seconds()
if second_difference > settings.TIME_BEFORE_REMOVING_STARTED_MODEL:
log.info("Model for problem {0} started over {1} seconds ago, removing and re-attempting.".format(
problem_id, settings.TIME_BEFORE_REMOVING_STARTED_MODEL))
created_model.delete()
model_started = False
#If a model has not been started, then initialize an entry in the database to prevent other threads from duplicating work
if not model_started:
created_model_dict_initial={
'max_score' : max_score,
'prompt' : prompt,
'problem' : problem,
'model_relative_path' : relative_model_path,
'model_full_path' : full_model_path,
'number_of_essays' : graded_sub_count,
'creation_succeeded': False,
'creation_started' : True,
'target_number' : m,
}
created_model = CreatedModel(**created_model_dict_initial)
created_model.save()
transaction.commit_unless_managed()
if not isinstance(prompt, basestring):
try:
prompt = str(prompt)
except:
prompt = ""
prompt = prompt.encode('ascii', 'ignore')
#Call on the machine-learning repo to create a model
results = create.create(essay_text, scores, prompt)
scores = [int(score_item) for score_item in scores]
#Add in needed stuff that ml creator does not pass back
results.update({
'model_path' : full_model_path,
'relative_model_path' : relative_model_path
})
#Try to create model if ml model creator was successful
if results['success']:
try:
success, s3_public_url = save_model_file(results,settings.USE_S3_TO_STORE_MODELS)
results.update({'s3_public_url' : s3_public_url, 'success' : success})
if not success:
results['errors'].append("Could not save model.")
except:
results['errors'].append("Could not save model.")
results['s3_public_url'] = ""
log.exception("Problem saving ML model.")
created_model_dict_final={
'cv_kappa' : results['cv_kappa'],
'cv_mean_absolute_error' : results['cv_mean_absolute_error'],
'creation_succeeded': results['success'],
'creation_started' : False,
's3_public_url' : results['s3_public_url'],
'model_stored_in_s3' : settings.USE_S3_TO_STORE_MODELS,
's3_bucketname' : str(settings.S3_BUCKETNAME),
'model_relative_path' : relative_model_path,
'model_full_path' : full_model_path,
}
transaction.commit_unless_managed()
try:
CreatedModel.objects.filter(pk=created_model.pk).update(**created_model_dict_final)
except:
log.error("ModelCreator creation failed. Error: {0}".format(id))
log.debug("Location: {0} Creation Status: {1} Errors: {2}".format(
full_model_path,
results['success'],
results['errors'],
))
transaction.commit_unless_managed()
return True, "Creation succeeded."
print """\
_ __ __ __ ___ _ __ __ __
| | /| / /__ / /______ __ _ ___ / /____ / _ \__ ______/ |/ /__ / /____ / /
| |/ |/ / -_) / __/ _ \/ ' \/ -_) / __/ _ \ / ___/ // /___/ / _ \/ __/ -_)_/
|__/|__/\__/_/\__/\___/_/_/_/\__/ \__/\___/ /_/ \_, / /_/|_/\___/\__/\__(_)
/___/
"""
PATH = os.getcwd()
if not os.path.isfile(".metadata"):
arc = open(".metadata", "w")
arc.close()
while True: # Usando un while true, seleccionamos un comando
command = raw_input("Command: ")
if re.match(" *create", command):
create.create(command, PATH)
elif re.match(" *dir", command):
dir.op_dir(command, PATH)
elif re.match(" *show", command):
show.show(command, PATH)
elif re.match(" *edit", command):
edit.op_edit(command, PATH)
elif re.match(" *delete", command):
delete.op_delete(command, PATH)
elif re.match(" *find", command):
find.op_find(command)
elif command == "exit":
break
else:
print "Error: Incorrect Command\n"
"can_block": True,
"can_dodge": True,
"block_pct": 0.05,
"block_amt": 0.51,
"dodge_pct": 0.07,
"base_hp": 3000
},
"characters": characters
}
req = {
'body': json.dumps(fight_req)
}
print (json.dumps(fight_req))
response = create(req, None)
print(response)
data = json.loads(response['body'])
fight_id = data['id']
###
# Do attacks
party = []
for character in characters:
p = multiprocessing.Process(target=cast_attack, args=(fight_id, character,))
party.append(p)
p.start()
####
import sys
while True:
select = int(
raw_input(
"1.Read\n2.Create\n3.Copy\n4.Find\n5.Quit\nEnter a command..."))
print("Select is : " + str(select))
if (select == 1):
#assigns a new card number to an existing user
print("Reading...\n")
read.main()
break
elif (select == 2):
#Creates a new user in the database
print("Create New User\n")
create.create()
break
elif (select == 3):
#copies a card number from one user to another user
print("Copy card ID\n")
copy.copy()
break
elif (select == 4):
#locates a user in the database
print("find user\n")
break
elif (select == 5):
print("Program is now quitting...")
sys.exit(1)
else:
print("Not a valid selection. Try again\n")
try:
validate_post(parse(join(posts_folder, post_id)))
print "validate '%s': OK" % post_id
except LxmlError, e:
print "validate '%s': ERROR" % post_id
x = []
for err in e.error_log:
x.append("%s: %s: line %s: %s" % (
err.level_name, err.filename, err.line, err.message))
raise SystemExit("\n".join(x))
if opt.validate:
if opt.post_id:
posts = [opt.post_id]
else:
posts = listdir(posts_folder)
for post_id in posts:
validate(post_id)
if opt.create:
try:
create(posts_folder, theme_folder, process_command, sync_command)
except:
log = logging.getLogger("enkel.batteri.staticcms")
log.exception("--create failed.")
if __name__ == "__main__":
cli()
def create_plate_from_dataframe(dataframe,
plate_name,
project_name,
time_column=None,
data_columns=None,
useColumnsForNumber=False,
time_parse=None):
"""Build a plate from a dataframe.
Create a plate from the provided dataframe, copying data into the associated data_table.
Specifics of which columns of the dataframe to use, for time and od, are optional arguments.
A function for converting the time column into the timedelta type is another optional argument.
Args:
dataframe: Pandas dataframe to be copied into the database
plate_name: name for the new plate being created
time_column: integer index of column to use for time values
data_columns: array of integers to use as indices for OD data
useColumnsForNumber: if true, use the column names to specify the well number and column names in data_table
time_parse: function used to convert time column values into timedelta
Returns:
(plate, wells, data_table): The newly created plate, its wells, and data_table with copied data from the dataframe."""
if time_column is None:
time_column = 0
if time_parse:
dataframe.iloc[:,
time_column] = time_parse(dataframe.iloc[:,
time_column])
if data_columns is None:
data_columns = range(dataframe.shape[1])
data_columns.remove(time_column)
assert len(
data_columns) + 1 <= dataframe.shape[1], 'too many columns specified!'
project = session.query(models.Project).filter(
models.Project.name == project_name).one_or_none()
if project is None:
project = create.create(project={'name': project_name})
plate = models.Plate(name=plate_name, project=project)
session.add(plate)
session.commit()
numbers = range(len(data_columns))
if useColumnsForNumber:
numbers = dataframe.columns[data_columns]
wells = [models.Well(plate=plate, plate_number=n) for n in numbers]
session.add_all(wells)
session.commit()
table = create_plate_data_table(plate)
column_names = [str(x) for x in data_columns]
if useColumnsForNumber:
column_names = [str(dataframe.columns[i]) for i in data_columns]
copy_plate_dataframe_to_table(dataframe, table, data_columns, column_names)
return plate, wells, table
#!/usr/bin/env python
# usage: create_obs_table new_table_name
# WARNING: If table already exists it will be deleted and recreated, all rows and new or modified column are lost!
from create import create
columns = [
"name text", "i text", "elevation float8", "time timestamptz",
"weather_type text", "visibility float8", "temperature float8",
"wind_speed float8", "pressure float8", "wind_gust text",
"wind_direction text", "pressure_tendency text", "dew_point float8",
"screen_relative_humidity float8"
]
if __name__ == '__main__':
from sys import argv
create(argv[1], ",".join(columns))
from nnt import train, predict, trainmass
from create import create
import timeit
a = timeit.default_timer()
syn = create(2, 4)
X = [[0.1, 0.2, 0.3, 0.4], [0.2, 0.3, 0.4, 0.5], [0.4, 0.5, 0.6, 0.7],
[0.5, 0.6, 0.7, 0.8]]
y = [[0.5, 0.6], [0.6, 0.7], [0.8, 0.9], [0.9, 1]]
g, r = trainmass(X, y, syn, 2, 4, 1, 250000)
h = predict(syn, X[0], 2, 4)
h2 = predict(syn, [0.5, 0.6, 0.7, 0.8], 2, 4)
print(h)
print(h2)
print('---------------------------------------------')
syn = create(1, 4)
X = [[0.1, 0.2, 0.3, 0.4], [0.2, 0.3, 0.4, 0.5], [0.4, 0.5, 0.6, 0.7],
[0.5, 0.6, 0.7, 0.8]]
y = [[0.5], [0.6], [0.8], [0.9]]
g, r = trainmass(X, y, syn, 1, 4, 1, 250000)
h = predict(syn, X[0], 1, 4)
h2 = predict(syn, [0.5, 0.6, 0.7, 0.8], 1, 4)
print(h)
print(h2)
print('---------------------------------------------')
syn = create(2, 4)
X = [[0.1, 0.2, 0.3, 0.4], [0.2, 0.3, 0.4, 0.5], [0.4, 0.5, 0.6, 0.7],
[0.5, 0.6, 0.7, 0.8]]
y = [[0.5, 0.6], [0.6, 0.7], [0.8, 0.9], [0.9, 1]]
def checkurl(server,url,typefile):
host_name = url
if '?' in url:
host_name, arguments = url.split('?')
components = host_name.split('/')
if 'attach' in components:
#if 'detach' in components:
if 'create' in components:
final_argument_list = []
arg_split = arguments.split('&')
if 'volume' in components:
for i in xrange(0,2):
final_argument_list.append((arg_split[i].split('='))[1])
print final_argument_list
data.server_header(server,final_argument_list)
global VOLUME_LIST
args=final_argument_list
volume_name = str(args[0])
volume_size = args[1]
actual_size = str(int(float(volume_size)*(1024**3)))
#os.system('sudo rbd create %s --size %s'%(str(volume_name),str(actual_size)))
try:
os.system('sudo rbd create ' + volume_name + ' --size ' + volume_size +' -k /etc/ceph/ceph.client.admin.keyring')
#rbdInstance.create(ioctx,str(volume_name),actual_size)
os.system('sudo modprobe rbd')
os.system('sudo rbd map ' + volume_name + ' --pool rbd --name client.admin -k /etc/ceph/ceph.client.admin.keyring')
#os.system('sudo mkfs.ext4 -m0 /dev/rbd/rbd/' + volume_name)
#os.system('sudo rbd map %s --pool %s --name client.admin'%(str(volume_name),str(POOL_NAME)));
global VOLUME_LIST
volume_id=len(VOLUME_LIST)
VOLUME_LIST[int(volume_id)]=volume_name
print VOLUME_LIST
server.wfile.write(json_out({"volumeid":volume_id+1}))
except:
server.wfile.write(json_out({"volumeid":'0'}))
else:
for i in xrange(0,3):
final_argument_list.append((arg_split[i].split('='))[1])
print final_argument_list
create.create(server,final_argument_list)
#return jsonify(volumeid=volume_id)
#else:
# create.create(server,final_argument_list)
if 'destroy' in components:
final_argument_list = []
arg_split = arguments.split('=')
if 'volume' in components:
final_argument_list.append(arg_split[1])
global VOLUME_LIST
args=final_argument_list
volume_id = int(args[0])-1
if volume_id in VOLUME_LIST:
volume_name=str(VOLUME_LIST[int(volume_id)])
else:
print "here\n"
try:
os.system('sudo rbd unmap /dev/rbd/%s/%s'%(POOL_NAME,volume_name))
os.system("sudo rbd rm %s"%(volume_name))
server.wfile.write(json_out({"status":'1'}))
except:
server.wfile.write(json_out({"status":'0'}))
#rbdInstance.remove(ioctx,volume_name)
else:
final_argument_list.append(arg_split[1])
delete.destroy(server,final_argument_list)
pass
if 'types' in components:
data.server_header(server,200)
try:
f = typefile
fopen = open(f)
server.wfile.write(create.json_out(json.load(fopen)))
except Exception,e:
print str(e)
server.wfile.write(create.json_out({"status":0}))
if 'query' in components:
if 'volume' in components:
print 'volume'
else:
print "entered!!"
final_argument_list = int(arguments.split('=')[1])
query(server,final_argument_list)
if 'list' in components:
listimage(server)
#imports import RPi.GPIO as GPIO import create import time #initialization bot = create.create() bot.startSerial() bot.startBot() bot.fullMode() GPIO.setmode(GPIO.BOARD) buzzer_pin = 40 #set to GPIO pin 21 GPIO.setup(buzzer_pin, GPIO.IN) GPIO.setup(buzzer_pin, GPIO.OUT) #birthday instruction line birthday_bit = 29 GPIO.setup(birthday_bit, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #binary coded table lines data_1 = 31 data_2 = 33 data_3 = 35 data_4 = 37 data_5 = 19 data_6 = 21 KIT = 23 GPIO.setup(KIT, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(data_1, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(data_2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(data_3, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
config = load_config()
parser = argparse.ArgumentParser(description="Fill in a 0install feed template.")
parser.add_argument("template", help="the template file to process")
parser.add_argument("substitutions", metavar="name=value", help="values to insert", nargs="*")
parser.add_argument("-o", "--output", help="output filename")
args = parser.parse_args()
template = args.template
if not os.path.exists(template):
import create
create.create(args)
sys.exit(0)
if not template.endswith(".xml.template"):
die("Template must be named *.xml.template, not {template}".format(template=template))
output_file_stem = template[:-13]
env = {}
for subst in args.substitutions:
if "=" not in subst:
die("Substitutions must be in the form name=value, not {subst}".format(subst=subst))
name, value = subst.split("=", 1)
if name in env:
die("Multiple values given for {name}!".format(name=name))
env[name] = value
##### INPUT CHECKING ######
# only one of the three options must be set
if not (options.install ^ options.create ^ options.verify) or not (options.install or options.create or options.verify):
print parser.get_usage()
sys.exit(1)
# filter options that work only with install
if not options.install and (options.force or options.confs or options.repos):
print parser.get_usage()
sys.exit(2)
# create, install and verify takes at least one argument
if (options.create and len(args) != 1) or (options.install and len(args) < 2) or (options.verify and len(args) == 0):
print parser.get_usage()
sys.exit(3)
##### EXECUTE #######
if options.install:
wconf = args[0]
rconfs = split_args(options.confs)
repos = split_args(options.repos)
packages = args[1:]
install.install(packages, repos, rconfs, "/", wconf, options.force)
if options.create:
create.create(args[0])
if options.verify:
verify.verify(args)
def default(self, *args, **kwargs):
'''
This is the main handler for any requests
recieved on this mount point.
'''
usar = cherrypy.session.get("user", None)
if usar is not None:
print usar.keys()
if cherrypy.request.method != "GET" and usar is None:
# if we've setup a post-recieve hook, check out this first.
if self._triggerurl == cherrypy.request.path_info and cherrypy.request.app.vcs is not None:
# perhaps do some exception handling and put a warning on .app that merge conflict happened?
cherrypy.request.app.vcs.pull()
return ""
else:
# otherwise:
raise cherrypy.HTTPError(401, "Not authorized to %s to this source" % (cherrypy.request.method))
if "action" in kwargs:
action = kwargs['action']
else:
action = "view"
self.parsePath(args)
if cherrypy.request.method == "POST":
action = self._handlePost(args, **kwargs)
if action == "create" and usar is not None and cherrypy.request.resourceFileExt == ".rst":
import create
cherrypy.request.template = template = create.create()
print "Showing create page %s" % (cherrypy.request.path_info)
filename = cherrypy.request.path_info[1:]
title = filename.replace("/", ".")
heading = "=" * len(title)
somerst = ".. _%s:\n\n%s\n%s\n%s\n\nTODOC!\n\n.. contents ::\n :depth: 2\n\n=============\nFirst Section\n=============\n\n" % (
filename, heading, title, heading
)
template.rst = RstDocument()
template.rst.update(somerst)
template.encoded_rst = cgi.escape(template.rst.document)
template.title = "Creating: %s" % (template.rst.gettitle())
template.action = action
cherrypy.response.status = 404
return self.render()
elif action == "edit":
import edit
cherrypy.request.template = template = edit.edit()
elif action == "upload":
import upload
cherrypy.request.template = template = upload.upload()
elif action == "bare":
if 'id_prefix' in kwargs:
print "id_prefix: " + kwargs["id_prefix"]
return cherrypy.request.rst.render(settings_overrides={'id_prefix': kwargs['id_prefix']})
return cherrypy.request.rst.render()
else:
action = "view"
import master
cherrypy.request.template = template = master.master()
cherrypy.request.githublink = self.githubroot
template.action = action
if cherrypy.request.resourceFileExt != ".rst":
mimetype = mimetypes.guess_type(cherrypy.request.resourceFilePath)
cherrypy.response.headers["Content-Type"] = mimetype[0]
return open(cherrypy.request.resourceFilePath).read()
elif os.path.isfile(cherrypy.request.resourceFilePath):
template.rst = RstDocument(cherrypy.request.resourceFilePath)
template.encoded_rst = cgi.escape(template.rst.document)
template.title = template.rst.gettitle()
else:
get_parmas = urllib.quote(cherrypy.request.request_line.split()[1])
creating = get_parmas.find("action%3Dcreate")
print get_parmas
if creating == -1:
redir = get_parmas + "?action=create"
raise cherrypy.HTTPRedirect(redir)
else:
raise cherrypy.HTTPError(404)
return self.render()
def default(self, *args, **kwargs):
'''
This is the main handler for any requests
recieved on this mount point.
'''
usar = cherrypy.session.get("user", None)
if usar is not None:
print usar.keys()
if cherrypy.request.method != "GET" and usar is None:
# if we've setup a post-recieve hook, check out this first.
if self._triggerurl == cherrypy.request.path_info and cherrypy.request.app.vcs is not None:
# perhaps do some exception handling and put a warning on .app that merge conflict happened?
cherrypy.request.app.vcs.pull()
return ""
else:
# otherwise:
raise cherrypy.HTTPError(
401, "Not authorized to %s to this source" %
(cherrypy.request.method))
if "action" in kwargs:
action = kwargs['action']
else:
action = "view"
self.parsePath(args)
if cherrypy.request.method == "POST":
action = self._handlePost(args, **kwargs)
if action == "create" and usar is not None and cherrypy.request.resourceFileExt == ".rst":
import create
cherrypy.request.template = template = create.create()
print "Showing create page %s" % (cherrypy.request.path_info)
filename = cherrypy.request.path_info[1:]
title = filename.replace("/", ".")
heading = "=" * len(title)
somerst = ".. _%s:\n\n%s\n%s\n%s\n\nTODOC!\n\n.. contents ::\n :depth: 2\n\n=============\nFirst Section\n=============\n\n" % (
filename, heading, title, heading)
template.rst = RstDocument()
template.rst.update(somerst)
template.encoded_rst = cgi.escape(template.rst.document)
template.title = "Creating: %s" % (template.rst.gettitle())
template.action = action
cherrypy.response.status = 404
return self.render()
elif action == "edit":
import edit
cherrypy.request.template = template = edit.edit()
elif action == "upload":
import upload
cherrypy.request.template = template = upload.upload()
elif action == "bare":
if 'id_prefix' in kwargs:
print "id_prefix: " + kwargs["id_prefix"]
return cherrypy.request.rst.render(
settings_overrides={'id_prefix': kwargs['id_prefix']})
return cherrypy.request.rst.render()
else:
action = "view"
import master
cherrypy.request.template = template = master.master()
cherrypy.request.githublink = self.githubroot
template.action = action
if cherrypy.request.resourceFileExt != ".rst":
mimetype = mimetypes.guess_type(cherrypy.request.resourceFilePath)
cherrypy.response.headers["Content-Type"] = mimetype[0]
return open(cherrypy.request.resourceFilePath).read()
elif os.path.isfile(cherrypy.request.resourceFilePath):
template.rst = RstDocument(cherrypy.request.resourceFilePath)
template.encoded_rst = cgi.escape(template.rst.document)
template.title = template.rst.gettitle()
else:
get_parmas = urllib.quote(cherrypy.request.request_line.split()[1])
creating = get_parmas.find("action%3Dcreate")
print get_parmas
if creating == -1:
redir = get_parmas + "?action=create"
raise cherrypy.HTTPRedirect(redir)
else:
raise cherrypy.HTTPError(404)
return self.render()
# Its an addition script if filename has add_ in it and its a python file
if 'add_' in local_mod and ext == 'py':
mod = importlib.import_module(local_mod)
# Collect the main functions as a dictionary for verbose execution
addition_scripts[local_mod] = mod.main
# Initialize an error tracking dictionary for reporting at the end
errors[local_mod] = 0
log.debug(
'Found addition script {}.py, staging for execution...'.format(
local_mod))
# Clear out the database
create()
# Offer to resample the smp data
resample_smp()
# Offer to convert the uavsar data (REQUIRED on your first attempt)
convert_uavsar()
# Run all the upload scripts
total_errors = 0
for name, fn in addition_scripts.items():
try:
n_errors = fn()
total_errors += n_errors
errors[name] = n_errors
def etl():
create()
nlist = []
for a in range(0,cs):
number = number + pat[a]
nlist.append(number)
return nlist
def searcher(list):
alist = hefresh(list)
dif = checker(alist)
if dif == 0: #we got no answer
print "We got nothing!"
else: #in any other case - (therefore we got an answer)
text = ""
for i in list:
text = str(text) + str(i) + " "
print text
finish(list,alist,dif)
list = create()
#print multi(list)
print finder(list)
#list = create()
#print checker([])
#searcher(list)
#
Basket.create_table(read_capacity_units=100,
write_capacity_units=100,
wait=True)
customer_id = str(uuid4())
print('###Test creating basket')
for x in range(1, 6):
item = {
"customer_id": customer_id,
"product_id": str(x),
"price": random.uniform(0.99, 10.99),
"quantity": random.randint(1, 10)
}
event = {'body': json.dumps(item)}
print(json.dumps(create(event, None)))
print()
print('###Test getting basket')
event = {'pathParameters': {'id': customer_id}}
result = list(event, None)
print(result)
del_event = {'pathParameters': {'id': customer_id, 'product_id': "2"}}
print()
print("###Test getting rid of an item")
print(delete(del_event, None))
def checkurl(server, url, typefile):
host_name = url
if "?" in url:
host_name, arguments = url.split("?")
components = host_name.split("/")
# if 'attach' in components:
# if 'detach' in components:
if "create" in components:
final_argument_list = []
arg_split = arguments.split("&")
if "volume" in components:
for i in xrange(0, 2):
final_argument_list.append((arg_split[i].split("="))[1])
print final_argument_list
data.server_header(server, final_argument_list)
global VOLUME_LIST
args = final_argument_list
volume_name = str(args[0])
volume_size = args[1]
actual_size = str(int(float(volume_size) * (1024 ** 3)))
# os.system('sudo rbd create %s --size %s'%(str(volume_name),str(actual_size)))
try:
global MID
rbdInstance.create(ioctx, volume_name, int(volume_size))
os.system("sudo rbd map %s --pool %s --name client.admin" % (volume_name, str(POOL_NAME)))
# os.system('sudo rbd create ' + volume_name + ' --size ' + volume_size +' -k /etc/ceph/ceph.client.admin.keyring')
# rbdInstance.create(ioctx,str(volume_name),actual_size)
# os.system('sudo modprobe rbd')
# os.system('sudo rbd map ' + volume_name + ' --pool rbd --name client.admin -k /etc/ceph/ceph.client.admin.keyring')
# os.system('sudo mkfs.ext4 -m0 /dev/rbd/rbd/' + volume_name)
# os.system('sudo rbd map %s --pool %s --name client.admin'%(str(volume_name),str(POOL_NAME)));
global VOLUME_LIST
MID = MID + 1
volume_id = MID
VOLUME_LIST[int(volume_id)] = [volume_name, volume_size, 0, 0]
print "list is", VOLUME_LIST
server.wfile.write(json_out({"volumeid": volume_id + 1}))
except:
server.wfile.write(json_out({"volumeid": "0"}))
else:
for i in xrange(0, 3):
final_argument_list.append((arg_split[i].split("="))[1])
print final_argument_list
create.create(server, final_argument_list)
# return jsonify(volumeid=volume_id)
# else:
# create.create(server,final_argument_list)
if "destroy" in components:
final_argument_list = []
arg_split = arguments.split("=")
if "volume" in components:
final_argument_list.append(arg_split[1])
global VOLUME_LIST
args = final_argument_list
volume_id = int(args[0]) - 1
if volume_id in VOLUME_LIST:
volume_name = str(VOLUME_LIST[int(volume_id)][0])
else:
print "here\n"
try:
os.system("sudo rbd unmap /dev/rbd/%s/%s" % (POOL_NAME, volume_name))
rbdInstance.remove(ioctx, volume_name)
# os.system("sudo rbd rm %s"%(volume_name))
server.wfile.write(json_out({"status": "1"}))
del VOLUME_LIST[volume_id]
except:
server.wfile.write(json_out({"status": "0"}))
# rbdInstance.remove(ioctx,volume_name)
else:
final_argument_list.append(arg_split[1])
delete.destroy(server, final_argument_list)
pass
if "types" in components:
data.server_header(server, 200)
try:
f = typefile
fopen = open(f)
server.wfile.write(create.json_out(json.load(fopen)))
except Exception, e:
print str(e)
server.wfile.write(create.json_out({"status": 0}))
